dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 #include <dali/public-api/events/mouse-button.h>
 475
 476 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 477 #include "web-view-signal-converter.h"
 478
 479 #include <dali/integration-api/debug.h>
 480
 481 // add here SWIG version check
 482
 483 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 484 // disable Swig-dependent warnings
 485
 486 // 'identifier1' has C-linkage specified,
 487 // but returns UDT 'identifier2' which is incompatible with C
 488 #pragma warning(disable: 4190)
 489
 490 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 491 #pragma warning(disable: 4800)
 492
 493 // debug info too long etc etc
 494 #pragma warning(disable: 4786)
 495 #endif
 496
 497
 498 #include <stdexcept>
 499
 500
 501 #include <string>
 502
 503
 504 #include <vector>
 505 #include <algorithm>
 506 #include <stdexcept>
 507
 508
 509 #include <map>
 510 #include <algorithm>
 511 #include <stdexcept>
 512
 513
 514 #include <utility>
 515
 516
 517 typedef float floatp;
 518
 519 SWIGINTERN floatp *new_floatp(){
 520   return new float();
 521 }
 522 SWIGINTERN void delete_floatp(floatp *self){
 523   if (self) delete self;
 524 }
 525 SWIGINTERN void floatp_assign(floatp *self,float value){
 526   *self = value;
 527 }
 528 SWIGINTERN float floatp_value(floatp *self){
 529   return *self;
 530 }
 531 SWIGINTERN float *floatp_cast(floatp *self){
 532   return self;
 533 }
 534 SWIGINTERN floatp *floatp_frompointer(float *t){
 535   return (floatp *) t;
 536 }
 537
 538 typedef int intp;
 539
 540 SWIGINTERN intp *new_intp(){
 541   return new int();
 542 }
 543 SWIGINTERN void delete_intp(intp *self){
 544   if (self) delete self;
 545 }
 546 SWIGINTERN void intp_assign(intp *self,int value){
 547   *self = value;
 548 }
 549 SWIGINTERN int intp_value(intp *self){
 550   return *self;
 551 }
 552 SWIGINTERN int *intp_cast(intp *self){
 553   return self;
 554 }
 555 SWIGINTERN intp *intp_frompointer(int *t){
 556   return (intp *) t;
 557 }
 558
 559 typedef double doublep;
 560
 561 SWIGINTERN doublep *new_doublep(){
 562   return new double();
 563 }
 564 SWIGINTERN void delete_doublep(doublep *self){
 565   if (self) delete self;
 566 }
 567 SWIGINTERN void doublep_assign(doublep *self,double value){
 568   *self = value;
 569 }
 570 SWIGINTERN double doublep_value(doublep *self){
 571   return *self;
 572 }
 573 SWIGINTERN double *doublep_cast(doublep *self){
 574   return self;
 575 }
 576 SWIGINTERN doublep *doublep_frompointer(double *t){
 577   return (doublep *) t;
 578 }
 579
 580 typedef unsigned int uintp;
 581
 582 SWIGINTERN uintp *new_uintp(){
 583   return new unsigned int();
 584 }
 585 SWIGINTERN void delete_uintp(uintp *self){
 586   if (self) delete self;
 587 }
 588 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 589   *self = value;
 590 }
 591 SWIGINTERN unsigned int uintp_value(uintp *self){
 592   return *self;
 593 }
 594 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 595   return self;
 596 }
 597 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 598   return (uintp *) t;
 599 }
 600
 601 typedef unsigned short ushortp;
 602
 603 SWIGINTERN ushortp *new_ushortp(){
 604   return new unsigned short();
 605 }
 606 SWIGINTERN void delete_ushortp(ushortp *self){
 607   if (self) delete self;
 608 }
 609 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 610   *self = value;
 611 }
 612 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 613   return *self;
 614 }
 615 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 616   return self;
 617 }
 618 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 619   return (ushortp *) t;
 620 }
 621
 622 unsigned int int_to_uint(int x) {
 623    return (unsigned int) x;
 624 }
 625
 626
 627 using namespace Dali;
 628 using namespace Dali::Toolkit;
 629
 630 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 631 {
 632   bool result = false;
 633   try
 634   {
 635     // C++ code. DALi uses Handle <-> Body design pattern.
 636     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 637     // Handles in DALi can be converted into a boolean type
 638     // to check if the handle has a valid body attached to it.
 639     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 640     if( *self )
 641     {
 642       result = true;
 643     }
 644     else
 645     {
 646       result = false;
 647     }
 648   }
 649   catch (std::out_of_range& e)
 650   {
 651     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 652     return 0;
 653   }
 654   catch (std::exception& e)
 655   {
 656     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 657     return 0;
 658   }
 659   catch (DaliException e)
 660   {
 661     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 662     return 0;
 663   }
 664   catch (...)
 665   {
 666     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 667     return 0;
 668   }
 669   return result;
 670 }
 671
 672 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 673 {
 674   bool result = false;
 675   try
 676   {
 677     // C++ code. Check if two handles reference the same implemtion
 678     if( *self == rhs)
 679     {
 680       result = true;
 681     }
 682     else
 683     {
 684       result = false;
 685     }
 686   }
 687   catch (std::out_of_range& e)
 688   {
 689     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 690     return 0;
 691   }
 692   catch (std::exception& e)
 693   {
 694     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 695     return 0;
 696   }
 697   catch (DaliException e)
 698   {
 699     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 700     return 0;
 701   }
 702   catch (...)
 703   {
 704     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 705     return 0;
 706   }
 707   return result;
 708 }
 709
 710
 711 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 712      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 713    }
 714 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 715      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 716    }
 717 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 718         std::vector< Dali::TouchPoint >* pv = 0;
 719         if (capacity >= 0) {
 720           pv = new std::vector< Dali::TouchPoint >();
 721           pv->reserve(capacity);
 722        } else {
 723           throw std::out_of_range("capacity");
 724        }
 725        return pv;
 726       }
 727 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 728         if (index>=0 && index<(int)self->size())
 729           return (*self)[index];
 730         else
 731           throw std::out_of_range("index");
 732       }
 733 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 734         if (index>=0 && index<(int)self->size())
 735           return (*self)[index];
 736         else
 737           throw std::out_of_range("index");
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 740         if (index>=0 && index<(int)self->size())
 741           (*self)[index] = val;
 742         else
 743           throw std::out_of_range("index");
 744       }
 745 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 746         self->insert(self->end(), values.begin(), values.end());
 747       }
 748 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 749         if (index < 0)
 750           throw std::out_of_range("index");
 751         if (count < 0)
 752           throw std::out_of_range("count");
 753         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 754           throw std::invalid_argument("invalid range");
 755         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 756       }
 757 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 758         if (index>=0 && index<(int)self->size()+1)
 759           self->insert(self->begin()+index, x);
 760         else
 761           throw std::out_of_range("index");
 762       }
 763 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 764         if (index>=0 && index<(int)self->size()+1)
 765           self->insert(self->begin()+index, values.begin(), values.end());
 766         else
 767           throw std::out_of_range("index");
 768       }
 769 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 770         if (index>=0 && index<(int)self->size())
 771           self->erase(self->begin() + index);
 772         else
 773           throw std::out_of_range("index");
 774       }
 775 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 776         if (index < 0)
 777           throw std::out_of_range("index");
 778         if (count < 0)
 779           throw std::out_of_range("count");
 780         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 781           throw std::invalid_argument("invalid range");
 782         self->erase(self->begin()+index, self->begin()+index+count);
 783       }
 784 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 785         if (count < 0)
 786           throw std::out_of_range("count");
 787         return new std::vector< Dali::TouchPoint >(count, value);
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 790         std::reverse(self->begin(), self->end());
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (count < 0)
 796           throw std::out_of_range("count");
 797         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 798           throw std::invalid_argument("invalid range");
 799         std::reverse(self->begin()+index, self->begin()+index+count);
 800       }
 801 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 802         if (index < 0)
 803           throw std::out_of_range("index");
 804         if (index+values.size() > self->size())
 805           throw std::out_of_range("index");
 806         std::copy(values.begin(), values.end(), self->begin()+index);
 807       }
 808 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 809          return self->Empty();
 810       }
 811 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 812         return self->GetConnectionCount();
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Connect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Disconnect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 821           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 822 /*@SWIG@*/ self->Emit( arg );
 823       }
 824 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825          return self->Empty();
 826       }
 827 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828         return self->GetConnectionCount();
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Connect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Disconnect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 837           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 838 /*@SWIG@*/ self->Emit( arg );
 839       }
 840 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 841          return self->Empty();
 842       }
 843 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844         return self->GetConnectionCount();
 845       }
 846 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 847           self->Connect( func );
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 850           self->Disconnect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 853           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 854 /*@SWIG@*/ self->Emit( arg );
 855       }
 856 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857          return self->Empty();
 858       }
 859 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860         return self->GetConnectionCount();
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Connect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Disconnect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 869           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 870 /*@SWIG@*/ self->Emit( arg );
 871       }
 872 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 873          return self->Empty();
 874       }
 875 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 876         return self->GetConnectionCount();
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Connect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 882           self->Disconnect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 885           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 886 /*@SWIG@*/ self->Emit( arg );
 887       }
 888 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 889          return self->Empty();
 890       }
 891 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 892         return self->GetConnectionCount();
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 895         self->Connect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 898         self->Disconnect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 901         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg1, arg2 );
 903       }
 904 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 905          return self->Empty();
 906       }
 907 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 908         return self->GetConnectionCount();
 909       }
 910 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 911         self->Connect( func );
 912       }
 913 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 914         self->Disconnect( func );
 915       }
 916 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 917         return self->Emit( arg1, arg2 );
 918       }
 919 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 920          return self->Empty();
 921       }
 922 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 923         return self->GetConnectionCount();
 924       }
 925 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 926         self->Connect( func );
 927       }
 928 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 929         self->Disconnect( func );
 930       }
 931 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 932         return self->Emit( arg1, arg2 );
 933       }
 934 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 935          return self->Empty();
 936       }
 937 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 938         return self->GetConnectionCount();
 939       }
 940 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 941         self->Connect( func );
 942       }
 943 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 944         self->Disconnect( func );
 945       }
 946 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 947         return self->Emit( arg1, arg2 );
 948       }
 949 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 950          return self->Empty();
 951       }
 952 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 953         return self->GetConnectionCount();
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Connect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 959           self->Disconnect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 962           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg );
 964       }
 965 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 966          return self->Empty();
 967       }
 968 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 969         return self->GetConnectionCount();
 970       }
 971 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 972           self->Connect( func );
 973       }
 974 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 975           self->Disconnect( func );
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 978           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg );
 980       }
 981 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 982          return self->Empty();
 983       }
 984 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 985         return self->GetConnectionCount();
 986       }
 987 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 988           self->Connect( func );
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 991           self->Disconnect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 994           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 998          return self->Empty();
 999       }
1000 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
1001         return self->GetConnectionCount();
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1004           self->Connect( func );
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1007           self->Disconnect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1014          return self->Empty();
1015       }
1016 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1017         return self->GetConnectionCount();
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1020         self->Connect( func );
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1023         self->Disconnect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1026         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1027 /*@SWIG@*/ self->Emit( arg1, arg2 );
1028       }
1029 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1030          return self->Empty();
1031       }
1032 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1033         return self->GetConnectionCount();
1034       }
1035 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1036         self->Connect( func );
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1039         self->Disconnect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1042         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1043 /*@SWIG@*/ self->Emit( arg1, arg2 );
1044       }
1045 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1046          return self->Empty();
1047       }
1048 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1049         return self->GetConnectionCount();
1050       }
1051 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1052         self->Connect( func );
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1055         self->Disconnect( func );
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1058         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1059 /*@SWIG@*/ self->Emit( arg1, arg2 );
1060       }
1061 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062          return self->Empty();
1063       }
1064 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1065         return self->GetConnectionCount();
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Connect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1071           self->Disconnect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1074           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1075 /*@SWIG@*/ self->Emit( arg );
1076       }
1077 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1078          return self->Empty();
1079       }
1080 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1081         return self->GetConnectionCount();
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1084           return self->Connect( func );
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1087           self->Disconnect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1090           self->Emit( arg1, arg3 );
1091       }
1092 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1093          return self->Empty();
1094       }
1095 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1096         return self->GetConnectionCount();
1097       }
1098 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1099           return self->Connect( func );
1100       }
1101 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1102           self->Disconnect( func );
1103       }
1104 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1105           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1106 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1107       }
1108
1109 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1110          return self->Empty();
1111       }
1112 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1113         return self->GetConnectionCount();
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Connect( func );
1117       }
1118 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1119           self->Disconnect( func );
1120       }
1121 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1122           return self->Emit();
1123       }
1124
1125 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1126         std::vector< unsigned int >* pv = 0;
1127         if (capacity >= 0) {
1128           pv = new std::vector< unsigned int >();
1129           pv->reserve(capacity);
1130        } else {
1131           throw std::out_of_range("capacity");
1132        }
1133        return pv;
1134       }
1135 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1142         if (index>=0 && index<(int)self->size())
1143           return (*self)[index];
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1148         if (index>=0 && index<(int)self->size())
1149           (*self)[index] = val;
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1154         self->insert(self->end(), values.begin(), values.end());
1155       }
1156 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1157         if (index < 0)
1158           throw std::out_of_range("index");
1159         if (count < 0)
1160           throw std::out_of_range("count");
1161         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1162           throw std::invalid_argument("invalid range");
1163         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, x);
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1172         if (index>=0 && index<(int)self->size()+1)
1173           self->insert(self->begin()+index, values.begin(), values.end());
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1178         if (index>=0 && index<(int)self->size())
1179           self->erase(self->begin() + index);
1180         else
1181           throw std::out_of_range("index");
1182       }
1183 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         self->erase(self->begin()+index, self->begin()+index+count);
1191       }
1192 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1193         if (count < 0)
1194           throw std::out_of_range("count");
1195         return new std::vector< unsigned int >(count, value);
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1198         std::reverse(self->begin(), self->end());
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (count < 0)
1204           throw std::out_of_range("count");
1205         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1206           throw std::invalid_argument("invalid range");
1207         std::reverse(self->begin()+index, self->begin()+index+count);
1208       }
1209 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1210         if (index < 0)
1211           throw std::out_of_range("index");
1212         if (index+values.size() > self->size())
1213           throw std::out_of_range("index");
1214         std::copy(values.begin(), values.end(), self->begin()+index);
1215       }
1216 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1217         return std::find(self->begin(), self->end(), value) != self->end();
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1222         if (it != self->end())
1223           index = (int)(it - self->begin());
1224         return index;
1225       }
1226 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1227         int index = -1;
1228         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1229         if (rit != self->rend())
1230           index = (int)(self->rend() - 1 - rit);
1231         return index;
1232       }
1233 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1234         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1235         if (it != self->end()) {
1236           self->erase(it);
1237           return true;
1238         }
1239         return false;
1240       }
1241 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1242         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1243         if (capacity >= 0) {
1244           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1245           pv->reserve(capacity);
1246        } else {
1247           throw std::out_of_range("capacity");
1248        }
1249        return pv;
1250       }
1251 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1258         if (index>=0 && index<(int)self->size())
1259           return (*self)[index];
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1264         if (index>=0 && index<(int)self->size())
1265           (*self)[index] = val;
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1270         self->insert(self->end(), values.begin(), values.end());
1271       }
1272 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1273         if (index < 0)
1274           throw std::out_of_range("index");
1275         if (count < 0)
1276           throw std::out_of_range("count");
1277         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1278           throw std::invalid_argument("invalid range");
1279         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, x);
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1288         if (index>=0 && index<(int)self->size()+1)
1289           self->insert(self->begin()+index, values.begin(), values.end());
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1294         if (index>=0 && index<(int)self->size())
1295           self->erase(self->begin() + index);
1296         else
1297           throw std::out_of_range("index");
1298       }
1299 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1300         if (index < 0)
1301           throw std::out_of_range("index");
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1305           throw std::invalid_argument("invalid range");
1306         self->erase(self->begin()+index, self->begin()+index+count);
1307       }
1308 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1309         if (count < 0)
1310           throw std::out_of_range("count");
1311         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1312       }
1313 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1314         std::reverse(self->begin(), self->end());
1315       }
1316 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (count < 0)
1320           throw std::out_of_range("count");
1321         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1322           throw std::invalid_argument("invalid range");
1323         std::reverse(self->begin()+index, self->begin()+index+count);
1324       }
1325 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1326         if (index < 0)
1327           throw std::out_of_range("index");
1328         if (index+values.size() > self->size())
1329           throw std::out_of_range("index");
1330         std::copy(values.begin(), values.end(), self->begin()+index);
1331       }
1332 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1333         std::vector< Dali::Actor >* pv = 0;
1334         if (capacity >= 0) {
1335           pv = new std::vector< Dali::Actor >();
1336           pv->reserve(capacity);
1337        } else {
1338           throw std::out_of_range("capacity");
1339        }
1340        return pv;
1341       }
1342 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1349         if (index>=0 && index<(int)self->size())
1350           return (*self)[index];
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1355         if (index>=0 && index<(int)self->size())
1356           (*self)[index] = val;
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1361         self->insert(self->end(), values.begin(), values.end());
1362       }
1363 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1364         if (index < 0)
1365           throw std::out_of_range("index");
1366         if (count < 0)
1367           throw std::out_of_range("count");
1368         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1369           throw std::invalid_argument("invalid range");
1370         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, x);
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1379         if (index>=0 && index<(int)self->size()+1)
1380           self->insert(self->begin()+index, values.begin(), values.end());
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1385         if (index>=0 && index<(int)self->size())
1386           self->erase(self->begin() + index);
1387         else
1388           throw std::out_of_range("index");
1389       }
1390 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1391         if (index < 0)
1392           throw std::out_of_range("index");
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1396           throw std::invalid_argument("invalid range");
1397         self->erase(self->begin()+index, self->begin()+index+count);
1398       }
1399 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1400         if (count < 0)
1401           throw std::out_of_range("count");
1402         return new std::vector< Dali::Actor >(count, value);
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1405         std::reverse(self->begin(), self->end());
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (count < 0)
1411           throw std::out_of_range("count");
1412         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1413           throw std::invalid_argument("invalid range");
1414         std::reverse(self->begin()+index, self->begin()+index+count);
1415       }
1416 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1417         if (index < 0)
1418           throw std::out_of_range("index");
1419         if (index+values.size() > self->size())
1420           throw std::out_of_range("index");
1421         std::copy(values.begin(), values.end(), self->begin()+index);
1422       }
1423 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424          return self->Empty();
1425       }
1426 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1427         return self->GetConnectionCount();
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1430           self->Connect( func );
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1433           self->Disconnect( func );
1434       }
1435 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1436           return self->Emit( arg );
1437       }
1438 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1439          return self->Empty();
1440       }
1441 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1442         return self->GetConnectionCount();
1443       }
1444 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1445         self->Connect( func );
1446       }
1447 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1448         self->Disconnect( func );
1449       }
1450 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1451         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1452 /*@SWIG@*/ self->Emit( arg1, arg2 );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1455          return self->Empty();
1456       }
1457 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1458         return self->GetConnectionCount();
1459       }
1460 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1461         self->Connect( func );
1462       }
1463 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1464         self->Disconnect( func );
1465       }
1466 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1467         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1468 /*@SWIG@*/ self->Emit( arg1, arg2 );
1469       }
1470 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471          return self->Empty();
1472       }
1473 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1474         return self->GetConnectionCount();
1475       }
1476 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1477         self->Connect( func );
1478       }
1479 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1480         self->Disconnect( func );
1481       }
1482 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1483         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1484 /*@SWIG@*/ self->Emit( arg1, arg2 );
1485       }
1486 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1487          return self->Empty();
1488       }
1489 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1490         return self->GetConnectionCount();
1491       }
1492 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1493         self->Connect( func );
1494       }
1495 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1496         self->Disconnect( func );
1497       }
1498 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1499         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1500 /*@SWIG@*/ self->Emit( arg1, arg2 );
1501       }
1502 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503          return self->Empty();
1504       }
1505 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1506         return self->GetConnectionCount();
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1509           self->Connect( func );
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1512           self->Disconnect( func );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1515           return self->Emit( arg );
1516       }
1517 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518          return self->Empty();
1519       }
1520 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1521         return self->GetConnectionCount();
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1524           self->Connect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1527           self->Disconnect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1530           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1531 /*@SWIG@*/ self->Emit( arg );
1532       }
1533 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1534          return self->Empty();
1535       }
1536 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1537         return self->GetConnectionCount();
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1540           return self->Connect( func );
1541       }
1542 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1543           self->Disconnect( func );
1544       }
1545 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1546           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1547 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1548       }
1549 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550          return self->Empty();
1551       }
1552 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1553         return self->GetConnectionCount();
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1556           self->Connect( func );
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1559           self->Disconnect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1562           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1563 /*@SWIG@*/ self->Emit( arg );
1564       }
1565 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1566          return self->Empty();
1567       }
1568 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1569         return self->GetConnectionCount();
1570       }
1571 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1572           return self->Connect( func );
1573       }
1574 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1575           self->Disconnect( func );
1576       }
1577 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1578           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1579 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1580       }
1581 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1582          return self->Empty();
1583       }
1584 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1585         return self->GetConnectionCount();
1586       }
1587 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1588           self->Connect( func );
1589       }
1590 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1591           self->Disconnect( func );
1592       }
1593 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1594           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1595 /*@SWIG@*/ self->Emit( arg );
1596       }
1597 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1598          return self->Empty();
1599       }
1600 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1601         return self->GetConnectionCount();
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1604           self->Connect( func );
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1607           self->Disconnect( func );
1608       }
1609 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1610           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1611 /*@SWIG@*/ self->Emit( arg );
1612       }
1613
1614
1615 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1616          return self->Empty();
1617       }
1618 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1619         return self->GetConnectionCount();
1620       }
1621 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1622         self->Connect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1625         self->Disconnect( func );
1626       }
1627 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1628         return self->Emit( arg1, arg2 );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631          return self->Empty();
1632       }
1633 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1634         return self->GetConnectionCount();
1635       }
1636 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1637           self->Connect( func );
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1640           self->Disconnect( func );
1641       }
1642 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1643           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1644 /*@SWIG@*/ self->Emit( arg );
1645       }
1646 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647          return self->Empty();
1648       }
1649 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1650         return self->GetConnectionCount();
1651       }
1652 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1653           self->Connect( func );
1654       }
1655 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1656           self->Disconnect( func );
1657       }
1658 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1659           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1660 /*@SWIG@*/ self->Emit( arg );
1661       }
1662 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1663          return self->Empty();
1664       }
1665 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1666         return self->GetConnectionCount();
1667       }
1668 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1669         self->Connect( func );
1670       }
1671 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1672         self->Disconnect( func );
1673       }
1674 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1675         return self->Emit( arg1, arg2 );
1676       }
1677 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1678          return self->Empty();
1679       }
1680 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1681         return self->GetConnectionCount();
1682       }
1683 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1684         self->Connect( func );
1685       }
1686 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1687         self->Disconnect( func );
1688       }
1689 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1690         return self->Emit( arg1, arg2 );
1691       }
1692
1693 /* ---------------------------------------------------
1694  * C++ director class methods
1695  * --------------------------------------------------- */
1696
1697 #include "dali_wrap.h"
1698
1699 /*
1700  *  Widget director
1701  */
1702 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1703   swig_init_callbacks();
1704 }
1705
1706 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1707 }
1708
1709 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1710   char * jcontentInfo = 0 ;
1711   void * jwindow  ;
1712
1713   if (!swig_callbackOnCreate) {
1714     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1715     return;
1716   } else {
1717     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1718     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1719     swig_callbackOnCreate(jcontentInfo, jwindow);
1720   }
1721 }
1722
1723 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1724   char * jcontentInfo = 0 ;
1725   int jtype  ;
1726
1727   if (!swig_callbackOnTerminate) {
1728     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1729     return;
1730   } else {
1731     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1732     jtype = (int)type;
1733     swig_callbackOnTerminate(jcontentInfo, jtype);
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnPause() {
1738   if (!swig_callbackOnPause) {
1739     Dali::Internal::Adaptor::Widget::OnPause();
1740     return;
1741   } else {
1742     swig_callbackOnPause();
1743   }
1744 }
1745
1746 void SwigDirector_WidgetImpl::OnResume() {
1747   if (!swig_callbackOnResume) {
1748     Dali::Internal::Adaptor::Widget::OnResume();
1749     return;
1750   } else {
1751     swig_callbackOnResume();
1752   }
1753 }
1754
1755 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1756   void * jwindow  ;
1757
1758   if (!swig_callbackOnResize) {
1759     Dali::Internal::Adaptor::Widget::OnResize(window);
1760     return;
1761   } else {
1762     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1763     swig_callbackOnResize(jwindow);
1764   }
1765 }
1766
1767 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1768   char * jcontentInfo = 0 ;
1769   int jforce  ;
1770
1771   if (!swig_callbackOnUpdate) {
1772     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1773     return;
1774   } else {
1775     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1776     jforce = force;
1777     swig_callbackOnUpdate(jcontentInfo, jforce);
1778   }
1779 }
1780
1781 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1782   void * jslotObserver = 0 ;
1783   void * jcallback = 0 ;
1784
1785   if (!swig_callbackSignalConnected) {
1786     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1787     return;
1788   } else {
1789     jslotObserver = (void *) slotObserver;
1790     jcallback = (void *) callback;
1791     swig_callbackSignalConnected(jslotObserver, jcallback);
1792   }
1793 }
1794
1795 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1796   void * jslotObserver = 0 ;
1797   void * jcallback = 0 ;
1798
1799   if (!swig_callbackSignalDisconnected) {
1800     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1801     return;
1802   } else {
1803     jslotObserver = (void *) slotObserver;
1804     jcallback = (void *) callback;
1805     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1806   }
1807 }
1808
1809 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1810
1811   swig_callbackOnCreate = callbackOnCreate;
1812   swig_callbackOnTerminate = callbackOnTerminate;
1813   swig_callbackOnPause = callbackOnPause;
1814   swig_callbackOnResume = callbackOnResume;
1815   swig_callbackOnResize = callbackOnResize;
1816   swig_callbackOnUpdate = callbackOnUpdate;
1817   swig_callbackSignalConnected = callbackSignalConnected;
1818   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1819 }
1820
1821 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1822   swig_callbackOnCreate = 0;
1823   swig_callbackOnTerminate = 0;
1824   swig_callbackOnPause = 0;
1825   swig_callbackOnResume = 0;
1826   swig_callbackOnResize = 0;
1827   swig_callbackOnUpdate = 0;
1828   swig_callbackSignalConnected = 0;
1829   swig_callbackSignalDisconnected = 0;
1830 }
1831
1832
1833 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1834   swig_init_callbacks();
1835 }
1836
1837 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1838
1839 }
1840
1841
1842 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1843   int jdepth  ;
1844
1845   if (!swig_callbackOnStageConnection) {
1846     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1847     return;
1848   } else {
1849     jdepth = depth;
1850     swig_callbackOnStageConnection(jdepth);
1851   }
1852 }
1853
1854 void SwigDirector_ViewImpl::OnStageDisconnection() {
1855   if (!swig_callbackOnStageDisconnection) {
1856     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1857     return;
1858   } else {
1859     swig_callbackOnStageDisconnection();
1860   }
1861 }
1862
1863 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1864   void * jchild = 0 ;
1865
1866   if (!swig_callbackOnChildAdd) {
1867     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1868     return;
1869   } else {
1870     jchild = (Dali::Actor *) &child;
1871     swig_callbackOnChildAdd(jchild);
1872   }
1873 }
1874
1875 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1876   void * jchild = 0 ;
1877
1878   if (!swig_callbackOnChildRemove) {
1879     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1880     return;
1881   } else {
1882     jchild = (Dali::Actor *) &child;
1883     swig_callbackOnChildRemove(jchild);
1884   }
1885 }
1886
1887 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1888   int jindex  ;
1889   void * jpropertyValue  ;
1890
1891   if (!swig_callbackOnPropertySet) {
1892     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1893     return;
1894   } else {
1895     jindex = index;
1896     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1897     swig_callbackOnPropertySet(jindex, jpropertyValue);
1898   }
1899 }
1900
1901 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1902   void * jtargetSize = 0 ;
1903
1904   if (!swig_callbackOnSizeSet) {
1905     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1906     return;
1907   } else {
1908     jtargetSize = (Dali::Vector3 *) &targetSize;
1909     swig_callbackOnSizeSet(jtargetSize);
1910   }
1911 }
1912
1913 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1914   void * janimation = 0 ;
1915   void * jtargetSize = 0 ;
1916
1917   if (!swig_callbackOnSizeAnimation) {
1918     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1919     return;
1920   } else {
1921     janimation = (Dali::Animation *) &animation;
1922     jtargetSize = (Dali::Vector3 *) &targetSize;
1923     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1924   }
1925 }
1926
1927 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1928   bool c_result = SwigValueInit< bool >() ;
1929   unsigned int jresult = 0 ;
1930   void * jarg0 = 0 ;
1931
1932   if (!swig_callbackOnTouchEvent) {
1933     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1934   } else {
1935     jarg0 = (Dali::TouchEvent *) &event;
1936     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1937     c_result = jresult ? true : false;
1938   }
1939   return c_result;
1940 }
1941
1942 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1943   bool c_result = SwigValueInit< bool >() ;
1944   unsigned int jresult = 0 ;
1945   void * jarg0 = 0 ;
1946
1947   if (!swig_callbackOnHoverEvent) {
1948     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1949   } else {
1950     jarg0 = (Dali::HoverEvent *) &event;
1951     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1952     c_result = jresult ? true : false;
1953   }
1954   return c_result;
1955 }
1956
1957 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1958   bool c_result = SwigValueInit< bool >() ;
1959   unsigned int jresult = 0 ;
1960   void * jarg0 = 0 ;
1961
1962   if (!swig_callbackOnKeyEvent) {
1963     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1964   } else {
1965     jarg0 = (Dali::KeyEvent *) &event;
1966     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1967     c_result = jresult ? true : false;
1968   }
1969   return c_result;
1970 }
1971
1972 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1973   bool c_result = SwigValueInit< bool >() ;
1974   unsigned int jresult = 0 ;
1975   void * jarg0 = 0 ;
1976
1977   if (!swig_callbackOnWheelEvent) {
1978     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1979   } else {
1980     jarg0 = (Dali::WheelEvent *) &event;
1981     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1982     c_result = jresult ? true : false;
1983   }
1984   return c_result;
1985 }
1986
1987 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1988   void * jsize = 0 ;
1989   void * jcontainer = 0 ;
1990
1991   if (!swig_callbackOnRelayout) {
1992     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1993     return;
1994   } else {
1995     jsize = (Dali::Vector2 *) &size;
1996     jcontainer = (Dali::RelayoutContainer *) &container;
1997     swig_callbackOnRelayout(jsize, jcontainer);
1998   }
1999 }
2000
2001 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2002   int jpolicy  ;
2003   int jdimension  ;
2004
2005   if (!swig_callbackOnSetResizePolicy) {
2006     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2007     return;
2008   } else {
2009     jpolicy = (int)policy;
2010     jdimension = (int)dimension;
2011     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2012   }
2013 }
2014
2015 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2016   Dali::Vector3 c_result ;
2017   void * jresult = 0 ;
2018
2019   if (!swig_callbackGetNaturalSize) {
2020     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2021   } else {
2022     jresult = (void *) swig_callbackGetNaturalSize();
2023     if (!jresult) {
2024       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2025       return c_result;
2026     }
2027     c_result = *(Dali::Vector3 *)jresult;
2028   }
2029   return c_result;
2030 }
2031
2032 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2033   float c_result = SwigValueInit< float >() ;
2034   float jresult = 0 ;
2035   void * jchild = 0 ;
2036   int jdimension  ;
2037
2038   if (!swig_callbackCalculateChildSize) {
2039     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2040   } else {
2041     jchild = (Dali::Actor *) &child;
2042     jdimension = (int)dimension;
2043     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2044     c_result = (float)jresult;
2045   }
2046   return c_result;
2047 }
2048
2049 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2050   float c_result = SwigValueInit< float >() ;
2051   float jresult = 0 ;
2052   float jwidth  ;
2053
2054   if (!swig_callbackGetHeightForWidth) {
2055     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2056   } else {
2057     jwidth = width;
2058     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2059     c_result = (float)jresult;
2060   }
2061   return c_result;
2062 }
2063
2064 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2065   float c_result = SwigValueInit< float >() ;
2066   float jresult = 0 ;
2067   float jheight  ;
2068
2069   if (!swig_callbackGetWidthForHeight) {
2070     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2071   } else {
2072     jheight = height;
2073     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2074     c_result = (float)jresult;
2075   }
2076   return c_result;
2077 }
2078
2079 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2080   bool c_result = SwigValueInit< bool >() ;
2081   unsigned int jresult = 0 ;
2082   int jdimension  ;
2083
2084   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2085     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2086   } else {
2087     jdimension = (int)dimension;
2088     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2089     c_result = jresult ? true : false;
2090   }
2091   return c_result;
2092 }
2093
2094 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2095   int jdimension  ;
2096
2097   if (!swig_callbackOnCalculateRelayoutSize) {
2098     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2099     return;
2100   } else {
2101     jdimension = (int)dimension;
2102     swig_callbackOnCalculateRelayoutSize(jdimension);
2103   }
2104 }
2105
2106 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2107   float jsize  ;
2108   int jdimension  ;
2109
2110   if (!swig_callbackOnLayoutNegotiated) {
2111     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2112     return;
2113   } else {
2114     jsize = size;
2115     jdimension = (int)dimension;
2116     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2117   }
2118 }
2119
2120 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2121   return Dali::CustomActorImpl::GetExtension();
2122 }
2123
2124 void SwigDirector_ViewImpl::OnInitialize() {
2125   if (!swig_callbackOnInitialize) {
2126     Dali::Toolkit::Internal::Control::OnInitialize();
2127     return;
2128   } else {
2129     swig_callbackOnInitialize();
2130   }
2131 }
2132
2133 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2134   void * jchild = 0 ;
2135
2136   if (!swig_callbackOnControlChildAdd) {
2137     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2138     return;
2139   } else {
2140     jchild = (Dali::Actor *) &child;
2141     swig_callbackOnControlChildAdd(jchild);
2142   }
2143 }
2144
2145 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2146   void * jchild = 0 ;
2147
2148   if (!swig_callbackOnControlChildRemove) {
2149     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2150     return;
2151   } else {
2152     jchild = (Dali::Actor *) &child;
2153     swig_callbackOnControlChildRemove(jchild);
2154   }
2155 }
2156
2157 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2158   void * jstyleManager  ;
2159   int jchange  ;
2160
2161   if (!swig_callbackOnStyleChange) {
2162     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2163     return;
2164   } else {
2165     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2166     jchange = (int)change;
2167     swig_callbackOnStyleChange(jstyleManager, jchange);
2168   }
2169 }
2170
2171 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2172   bool c_result = SwigValueInit< bool >() ;
2173   unsigned int jresult = 0 ;
2174
2175   if (!swig_callbackOnAccessibilityActivated) {
2176     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2177   } else {
2178     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2179     c_result = jresult ? true : false;
2180   }
2181   return c_result;
2182 }
2183
2184 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2185   bool c_result = SwigValueInit< bool >() ;
2186   unsigned int jresult = 0 ;
2187   void * jgesture  ;
2188
2189   if (!swig_callbackOnAccessibilityPan) {
2190     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2191   } else {
2192     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2193     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2194     c_result = jresult ? true : false;
2195   }
2196   return c_result;
2197 }
2198
2199 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2200   bool c_result = SwigValueInit< bool >() ;
2201   unsigned int jresult = 0 ;
2202   void * jtouchEvent = 0 ;
2203
2204   if (!swig_callbackOnAccessibilityTouch) {
2205     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2206   } else {
2207     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2208     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2209     c_result = jresult ? true : false;
2210   }
2211   return c_result;
2212 }
2213
2214 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2215   bool c_result = SwigValueInit< bool >() ;
2216   unsigned int jresult = 0 ;
2217   unsigned int jisIncrease  ;
2218
2219   if (!swig_callbackOnAccessibilityValueChange) {
2220     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2221   } else {
2222     jisIncrease = isIncrease;
2223     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2224     c_result = jresult ? true : false;
2225   }
2226   return c_result;
2227 }
2228
2229 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2230   bool c_result = SwigValueInit< bool >() ;
2231   unsigned int jresult = 0 ;
2232
2233   if (!swig_callbackOnAccessibilityZoom) {
2234     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2235   } else {
2236     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2237     c_result = jresult ? true : false;
2238   }
2239   return c_result;
2240 }
2241
2242 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2243   if (!swig_callbackOnKeyInputFocusGained) {
2244     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2245     return;
2246   } else {
2247     swig_callbackOnKeyInputFocusGained();
2248   }
2249 }
2250
2251 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2252   if (!swig_callbackOnKeyInputFocusLost) {
2253     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2254     return;
2255   } else {
2256     swig_callbackOnKeyInputFocusLost();
2257   }
2258 }
2259
2260 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2261   Dali::Actor c_result ;
2262   void * jresult = 0 ;
2263   void * jcurrentFocusedActor  ;
2264   int jdirection  ;
2265   unsigned int jloopEnabled  ;
2266
2267   if (!swig_callbackGetNextKeyboardFocusableActor) {
2268     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2269   } else {
2270     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2271     jdirection = (int)direction;
2272     jloopEnabled = loopEnabled;
2273     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2274     if (!jresult) {
2275       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2276       return c_result;
2277     }
2278     c_result = *(Dali::Actor *)jresult;
2279   }
2280   return c_result;
2281 }
2282
2283 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2284   void * jcommitedFocusableActor  ;
2285
2286   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2287     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2288     return;
2289   } else {
2290     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2291     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2292   }
2293 }
2294
2295 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2296   bool c_result = SwigValueInit< bool >() ;
2297   unsigned int jresult = 0 ;
2298
2299   if (!swig_callbackOnKeyboardEnter) {
2300     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2301   } else {
2302     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2303     c_result = jresult ? true : false;
2304   }
2305   return c_result;
2306 }
2307
2308 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2309   void * jpinch = 0 ;
2310
2311   if (!swig_callbackOnPinch) {
2312     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2313     return;
2314   } else {
2315     jpinch = (Dali::PinchGesture *) &pinch;
2316     swig_callbackOnPinch(jpinch);
2317   }
2318 }
2319
2320 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2321   void * jpan = 0 ;
2322
2323   if (!swig_callbackOnPan) {
2324     Dali::Toolkit::Internal::Control::OnPan(pan);
2325     return;
2326   } else {
2327     jpan = (Dali::PanGesture *) &pan;
2328     swig_callbackOnPan(jpan);
2329   }
2330 }
2331
2332 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2333   void * jtap = 0 ;
2334
2335   if (!swig_callbackOnTap) {
2336     Dali::Toolkit::Internal::Control::OnTap(tap);
2337     return;
2338   } else {
2339     jtap = (Dali::TapGesture *) &tap;
2340     swig_callbackOnTap(jtap);
2341   }
2342 }
2343
2344 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2345   void * jlongPress = 0 ;
2346
2347   if (!swig_callbackOnLongPress) {
2348     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2349     return;
2350   } else {
2351     jlongPress = (Dali::LongPressGesture *) &longPress;
2352     swig_callbackOnLongPress(jlongPress);
2353   }
2354 }
2355
2356 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2357   void * jslotObserver = 0 ;
2358   void * jcallback = 0 ;
2359
2360   if (!swig_callbackSignalConnected) {
2361     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2362     return;
2363   } else {
2364     jslotObserver = (void *) slotObserver;
2365     jcallback = (void *) callback;
2366     swig_callbackSignalConnected(jslotObserver, jcallback);
2367   }
2368 }
2369
2370 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2371   void * jslotObserver = 0 ;
2372   void * jcallback = 0 ;
2373
2374   if (!swig_callbackSignalDisconnected) {
2375     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2376     return;
2377   } else {
2378     jslotObserver = (void *) slotObserver;
2379     jcallback = (void *) callback;
2380     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2381   }
2382 }
2383
2384 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2385   return Dali::Toolkit::Internal::Control::GetControlExtension();
2386 }
2387
2388 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2389   swig_callbackOnStageConnection = callbackOnStageConnection;
2390   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2391   swig_callbackOnChildAdd = callbackOnChildAdd;
2392   swig_callbackOnChildRemove = callbackOnChildRemove;
2393   swig_callbackOnPropertySet = callbackOnPropertySet;
2394   swig_callbackOnSizeSet = callbackOnSizeSet;
2395   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2396   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2397   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2398   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2399   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2400   swig_callbackOnRelayout = callbackOnRelayout;
2401   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2402   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2403   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2404   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2405   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2406   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2407   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2408   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2409   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2410   swig_callbackOnInitialize = callbackOnInitialize;
2411   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2412   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2413   swig_callbackOnStyleChange = callbackOnStyleChange;
2414   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2415   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2416   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2417   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2418   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2419   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2420   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2421   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2422   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2423   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2424   swig_callbackOnPinch = callbackOnPinch;
2425   swig_callbackOnPan = callbackOnPan;
2426   swig_callbackOnTap = callbackOnTap;
2427   swig_callbackOnLongPress = callbackOnLongPress;
2428   swig_callbackSignalConnected = callbackSignalConnected;
2429   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2430 }
2431
2432 void SwigDirector_ViewImpl::swig_init_callbacks() {
2433   swig_callbackOnStageConnection = 0;
2434   swig_callbackOnStageDisconnection = 0;
2435   swig_callbackOnChildAdd = 0;
2436   swig_callbackOnChildRemove = 0;
2437   swig_callbackOnPropertySet = 0;
2438   swig_callbackOnSizeSet = 0;
2439   swig_callbackOnSizeAnimation = 0;
2440   swig_callbackOnTouchEvent = 0;
2441   swig_callbackOnHoverEvent = 0;
2442   swig_callbackOnKeyEvent = 0;
2443   swig_callbackOnWheelEvent = 0;
2444   swig_callbackOnRelayout = 0;
2445   swig_callbackOnSetResizePolicy = 0;
2446   swig_callbackGetNaturalSize = 0;
2447   swig_callbackCalculateChildSize = 0;
2448   swig_callbackGetHeightForWidth = 0;
2449   swig_callbackGetWidthForHeight = 0;
2450   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2451   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2452   swig_callbackOnCalculateRelayoutSize = 0;
2453   swig_callbackOnLayoutNegotiated = 0;
2454   swig_callbackOnInitialize = 0;
2455   swig_callbackOnControlChildAdd = 0;
2456   swig_callbackOnControlChildRemove = 0;
2457   swig_callbackOnStyleChange = 0;
2458   swig_callbackOnAccessibilityActivated = 0;
2459   swig_callbackOnAccessibilityPan = 0;
2460   swig_callbackOnAccessibilityTouch = 0;
2461   swig_callbackOnAccessibilityValueChange = 0;
2462   swig_callbackOnAccessibilityZoom = 0;
2463   swig_callbackOnKeyInputFocusGained = 0;
2464   swig_callbackOnKeyInputFocusLost = 0;
2465   swig_callbackGetNextKeyboardFocusableActor = 0;
2466   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2467   swig_callbackOnKeyboardEnter = 0;
2468   swig_callbackOnPinch = 0;
2469   swig_callbackOnPan = 0;
2470   swig_callbackOnTap = 0;
2471   swig_callbackOnLongPress = 0;
2472   swig_callbackSignalConnected = 0;
2473   swig_callbackSignalDisconnected = 0;
2474 }
2475
2476 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2477   swig_init_callbacks();
2478 }
2479
2480 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2481
2482 }
2483
2484
2485 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2486   unsigned int c_result = SwigValueInit< unsigned int >() ;
2487   unsigned int jresult = 0 ;
2488
2489   if (!swig_callbackGetNumberOfItems) {
2490     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2491   } else {
2492     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2493     c_result = (unsigned int)jresult;
2494   }
2495   return c_result;
2496 }
2497
2498 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2499   Dali::Actor c_result ;
2500   void * jresult = 0 ;
2501   unsigned int jitemId  ;
2502
2503   if (!swig_callbackNewItem) {
2504     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2505   } else {
2506     jitemId = itemId;
2507     jresult = (void *) swig_callbackNewItem(jitemId);
2508     if (!jresult) {
2509       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2510       return c_result;
2511     }
2512     c_result = *(Dali::Actor *)jresult;
2513   }
2514   return c_result;
2515 }
2516
2517 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2518   unsigned int jitemId  ;
2519   void * jactor  ;
2520
2521   if (!swig_callbackItemReleased) {
2522     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2523     return;
2524   } else {
2525     jitemId = itemId;
2526     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2527     swig_callbackItemReleased(jitemId, jactor);
2528   }
2529 }
2530
2531 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2532   return Dali::Toolkit::ItemFactory::GetExtension();
2533 }
2534
2535 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2536   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2537   swig_callbackNewItem = callbackNewItem;
2538   swig_callbackItemReleased = callbackItemReleased;
2539 }
2540
2541 void SwigDirector_ItemFactory::swig_init_callbacks() {
2542   swig_callbackGetNumberOfItems = 0;
2543   swig_callbackNewItem = 0;
2544   swig_callbackItemReleased = 0;
2545 }
2546
2547 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2548   swig_init_callbacks();
2549 }
2550
2551 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2552
2553 }
2554
2555
2556 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2557   Dali::Actor c_result ;
2558   void * jresult = 0 ;
2559   void * jcurrent  ;
2560   void * jproposed  ;
2561   int jdirection  ;
2562
2563   if (!swig_callbackGetNextFocusableActor) {
2564     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2565   } else {
2566     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2567     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2568     jdirection = (int)direction;
2569     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2570     if (!jresult) {
2571       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2572       return c_result;
2573     }
2574     c_result = *(Dali::Actor *)jresult;
2575   }
2576   return c_result;
2577 }
2578
2579 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2580   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2581 }
2582
2583 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2584   swig_callbackGetNextFocusableActor = 0;
2585 }
2586
2587
2588 #ifdef __cplusplus
2589 extern "C" {
2590 #endif
2591
2592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2593   void * jresult ;
2594   floatp *result = 0 ;
2595
2596   {
2597     try {
2598       result = (floatp *)new_floatp();
2599     } catch (std::out_of_range& e) {
2600       {
2601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2602       };
2603     } catch (std::exception& e) {
2604       {
2605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2606       };
2607     } catch (DaliException e) {
2608       {
2609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2610       };
2611     } catch (...) {
2612       {
2613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2614       };
2615     }
2616   }
2617   jresult = (void *)result;
2618   return jresult;
2619 }
2620
2621
2622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2623   floatp *arg1 = (floatp *) 0 ;
2624
2625   arg1 = (floatp *)jarg1;
2626   {
2627     try {
2628       delete_floatp(arg1);
2629     } catch (std::out_of_range& e) {
2630       {
2631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2632       };
2633     } catch (std::exception& e) {
2634       {
2635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2636       };
2637     } catch (Dali::DaliException e) {
2638       {
2639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2640       };
2641     } catch (...) {
2642       {
2643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2644       };
2645     }
2646   }
2647
2648 }
2649
2650
2651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2652   floatp *arg1 = (floatp *) 0 ;
2653   float arg2 ;
2654
2655   arg1 = (floatp *)jarg1;
2656   arg2 = (float)jarg2;
2657   {
2658     try {
2659       floatp_assign(arg1,arg2);
2660     } catch (std::out_of_range& e) {
2661       {
2662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2663       };
2664     } catch (std::exception& e) {
2665       {
2666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2667       };
2668     } catch (Dali::DaliException e) {
2669       {
2670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2671       };
2672     } catch (...) {
2673       {
2674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2675       };
2676     }
2677   }
2678
2679 }
2680
2681
2682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2683   float jresult ;
2684   floatp *arg1 = (floatp *) 0 ;
2685   float result;
2686
2687   arg1 = (floatp *)jarg1;
2688   {
2689     try {
2690       result = (float)floatp_value(arg1);
2691     } catch (std::out_of_range& e) {
2692       {
2693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2694       };
2695     } catch (std::exception& e) {
2696       {
2697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2698       };
2699     } catch (DaliException e) {
2700       {
2701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2702       };
2703     } catch (...) {
2704       {
2705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2706       };
2707     }
2708   }
2709   jresult = result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2715   void * jresult ;
2716   floatp *arg1 = (floatp *) 0 ;
2717   float *result = 0 ;
2718
2719   arg1 = (floatp *)jarg1;
2720   {
2721     try {
2722       result = (float *)floatp_cast(arg1);
2723     } catch (std::out_of_range& e) {
2724       {
2725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2726       };
2727     } catch (std::exception& e) {
2728       {
2729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (Dali::DaliException e) {
2732       {
2733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741
2742   jresult = (void *)result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2748   void * jresult ;
2749   float *arg1 = (float *) 0 ;
2750   floatp *result = 0 ;
2751
2752   arg1 = (float *)jarg1;
2753   {
2754     try {
2755       result = (floatp *)floatp_frompointer(arg1);
2756     } catch (std::out_of_range& e) {
2757       {
2758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (std::exception& e) {
2761       {
2762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (Dali::DaliException e) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2767       };
2768     } catch (...) {
2769       {
2770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2771       };
2772     }
2773   }
2774
2775   jresult = (void *)result;
2776   return jresult;
2777 }
2778
2779
2780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2781   void * jresult ;
2782   intp *result = 0 ;
2783
2784   {
2785     try {
2786       result = (intp *)new_intp();
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (Dali::DaliException e) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2798       };
2799     } catch (...) {
2800       {
2801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2802       };
2803     }
2804   }
2805
2806   jresult = (void *)result;
2807   return jresult;
2808 }
2809
2810
2811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2812   intp *arg1 = (intp *) 0 ;
2813
2814   arg1 = (intp *)jarg1;
2815   {
2816     try {
2817       delete_intp(arg1);
2818     } catch (std::out_of_range& e) {
2819       {
2820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2821       };
2822     } catch (std::exception& e) {
2823       {
2824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2825       };
2826     } catch (Dali::DaliException e) {
2827       {
2828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2829       };
2830     } catch (...) {
2831       {
2832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2833       };
2834     }
2835   }
2836
2837 }
2838
2839
2840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2841   intp *arg1 = (intp *) 0 ;
2842   int arg2 ;
2843
2844   arg1 = (intp *)jarg1;
2845   arg2 = (int)jarg2;
2846   {
2847     try {
2848       intp_assign(arg1,arg2);
2849     } catch (std::out_of_range& e) {
2850       {
2851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2852       };
2853     } catch (std::exception& e) {
2854       {
2855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2856       };
2857     } catch (Dali::DaliException e) {
2858       {
2859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2860       };
2861     } catch (...) {
2862       {
2863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2864       };
2865     }
2866   }
2867
2868 }
2869
2870
2871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2872   int jresult ;
2873   intp *arg1 = (intp *) 0 ;
2874   int result;
2875
2876   arg1 = (intp *)jarg1;
2877   {
2878     try {
2879       result = (int)intp_value(arg1);
2880     } catch (std::out_of_range& e) {
2881       {
2882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2883       };
2884     } catch (std::exception& e) {
2885       {
2886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2887       };
2888     } catch (Dali::DaliException e) {
2889       {
2890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2891       };
2892     } catch (...) {
2893       {
2894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2895       };
2896     }
2897   }
2898
2899   jresult = result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2905   void * jresult ;
2906   intp *arg1 = (intp *) 0 ;
2907   int *result = 0 ;
2908
2909   arg1 = (intp *)jarg1;
2910   {
2911     try {
2912       result = (int *)intp_cast(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2920       };
2921     } catch (Dali::DaliException e) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2924       };
2925     } catch (...) {
2926       {
2927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2928       };
2929     }
2930   }
2931
2932   jresult = (void *)result;
2933   return jresult;
2934 }
2935
2936
2937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2938   void * jresult ;
2939   int *arg1 = (int *) 0 ;
2940   intp *result = 0 ;
2941
2942   arg1 = (int *)jarg1;
2943   {
2944     try {
2945       result = (intp *)intp_frompointer(arg1);
2946     } catch (std::out_of_range& e) {
2947       {
2948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (std::exception& e) {
2951       {
2952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (Dali::DaliException e) {
2955       {
2956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2957       };
2958     } catch (...) {
2959       {
2960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2961       };
2962     }
2963   }
2964
2965   jresult = (void *)result;
2966   return jresult;
2967 }
2968
2969
2970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2971   void * jresult ;
2972   doublep *result = 0 ;
2973
2974   {
2975     try {
2976       result = (doublep *)new_doublep();
2977     } catch (std::out_of_range& e) {
2978       {
2979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2980       };
2981     } catch (std::exception& e) {
2982       {
2983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2984       };
2985     } catch (Dali::DaliException e) {
2986       {
2987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2988       };
2989     } catch (...) {
2990       {
2991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2992       };
2993     }
2994   }
2995
2996   jresult = (void *)result;
2997   return jresult;
2998 }
2999
3000
3001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3002   doublep *arg1 = (doublep *) 0 ;
3003
3004   arg1 = (doublep *)jarg1;
3005   {
3006     try {
3007       delete_doublep(arg1);
3008     } catch (std::out_of_range& e) {
3009       {
3010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3011       };
3012     } catch (std::exception& e) {
3013       {
3014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3015       };
3016     } catch (Dali::DaliException e) {
3017       {
3018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3019       };
3020     } catch (...) {
3021       {
3022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3023       };
3024     }
3025   }
3026
3027 }
3028
3029
3030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3031   doublep *arg1 = (doublep *) 0 ;
3032   double arg2 ;
3033
3034   arg1 = (doublep *)jarg1;
3035   arg2 = (double)jarg2;
3036   {
3037     try {
3038       doublep_assign(arg1,arg2);
3039     } catch (std::out_of_range& e) {
3040       {
3041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3042       };
3043     } catch (std::exception& e) {
3044       {
3045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3046       };
3047     } catch (Dali::DaliException e) {
3048       {
3049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3050       };
3051     } catch (...) {
3052       {
3053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3054       };
3055     }
3056   }
3057
3058 }
3059
3060
3061 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3062   double jresult ;
3063   doublep *arg1 = (doublep *) 0 ;
3064   double result;
3065
3066   arg1 = (doublep *)jarg1;
3067   {
3068     try {
3069       result = (double)doublep_value(arg1);
3070     } catch (std::out_of_range& e) {
3071       {
3072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (std::exception& e) {
3075       {
3076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3077       };
3078     } catch (Dali::DaliException e) {
3079       {
3080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3085       };
3086     }
3087   }
3088
3089   jresult = result;
3090   return jresult;
3091 }
3092
3093
3094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3095   void * jresult ;
3096   doublep *arg1 = (doublep *) 0 ;
3097   double *result = 0 ;
3098
3099   arg1 = (doublep *)jarg1;
3100   {
3101     try {
3102       result = (double *)doublep_cast(arg1);
3103     } catch (std::out_of_range& e) {
3104       {
3105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (std::exception& e) {
3108       {
3109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (Dali::DaliException e) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121
3122   jresult = (void *)result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3128   void * jresult ;
3129   double *arg1 = (double *) 0 ;
3130   doublep *result = 0 ;
3131
3132   arg1 = (double *)jarg1;
3133   {
3134     try {
3135       result = (doublep *)doublep_frompointer(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3143       };
3144     } catch (Dali::DaliException e) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3147       };
3148     } catch (...) {
3149       {
3150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3151       };
3152     }
3153   }
3154
3155   jresult = (void *)result;
3156   return jresult;
3157 }
3158
3159
3160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3161   void * jresult ;
3162   uintp *result = 0 ;
3163
3164   {
3165     try {
3166       result = (uintp *)new_uintp();
3167     } catch (std::out_of_range& e) {
3168       {
3169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3170       };
3171     } catch (std::exception& e) {
3172       {
3173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3174       };
3175     } catch (Dali::DaliException e) {
3176       {
3177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3178       };
3179     } catch (...) {
3180       {
3181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3182       };
3183     }
3184   }
3185
3186   jresult = (void *)result;
3187   return jresult;
3188 }
3189
3190
3191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3192   uintp *arg1 = (uintp *) 0 ;
3193
3194   arg1 = (uintp *)jarg1;
3195   {
3196     try {
3197       delete_uintp(arg1);
3198     } catch (std::out_of_range& e) {
3199       {
3200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3201       };
3202     } catch (std::exception& e) {
3203       {
3204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3205       };
3206     } catch (Dali::DaliException e) {
3207       {
3208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3209       };
3210     } catch (...) {
3211       {
3212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3213       };
3214     }
3215   }
3216
3217 }
3218
3219
3220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3221   uintp *arg1 = (uintp *) 0 ;
3222   unsigned int arg2 ;
3223
3224   arg1 = (uintp *)jarg1;
3225   arg2 = (unsigned int)jarg2;
3226   {
3227     try {
3228       uintp_assign(arg1,arg2);
3229     } catch (std::out_of_range& e) {
3230       {
3231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3232       };
3233     } catch (std::exception& e) {
3234       {
3235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3236       };
3237     } catch (Dali::DaliException e) {
3238       {
3239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3240       };
3241     } catch (...) {
3242       {
3243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3244       };
3245     }
3246   }
3247
3248 }
3249
3250
3251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3252   unsigned int jresult ;
3253   uintp *arg1 = (uintp *) 0 ;
3254   unsigned int result;
3255
3256   arg1 = (uintp *)jarg1;
3257   {
3258     try {
3259       result = (unsigned int)uintp_value(arg1);
3260     } catch (std::out_of_range& e) {
3261       {
3262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3263       };
3264     } catch (std::exception& e) {
3265       {
3266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (Dali::DaliException e) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278
3279   jresult = result;
3280   return jresult;
3281 }
3282
3283
3284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3285   void * jresult ;
3286   uintp *arg1 = (uintp *) 0 ;
3287   unsigned int *result = 0 ;
3288
3289   arg1 = (uintp *)jarg1;
3290   {
3291     try {
3292       result = (unsigned int *)uintp_cast(arg1);
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (Dali::DaliException e) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3304       };
3305     } catch (...) {
3306       {
3307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3308       };
3309     }
3310   }
3311
3312   jresult = (void *)result;
3313   return jresult;
3314 }
3315
3316
3317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3318   void * jresult ;
3319   unsigned int *arg1 = (unsigned int *) 0 ;
3320   uintp *result = 0 ;
3321
3322   arg1 = (unsigned int *)jarg1;
3323   {
3324     try {
3325       result = (uintp *)uintp_frompointer(arg1);
3326     } catch (std::out_of_range& e) {
3327       {
3328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3329       };
3330     } catch (std::exception& e) {
3331       {
3332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3333       };
3334     } catch (Dali::DaliException e) {
3335       {
3336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3337       };
3338     } catch (...) {
3339       {
3340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3341       };
3342     }
3343   }
3344
3345   jresult = (void *)result;
3346   return jresult;
3347 }
3348
3349
3350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3351   void * jresult ;
3352   ushortp *result = 0 ;
3353
3354   {
3355     try {
3356       result = (ushortp *)new_ushortp();
3357     } catch (std::out_of_range& e) {
3358       {
3359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3360       };
3361     } catch (std::exception& e) {
3362       {
3363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3364       };
3365     } catch (Dali::DaliException e) {
3366       {
3367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3368       };
3369     } catch (...) {
3370       {
3371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3372       };
3373     }
3374   }
3375
3376   jresult = (void *)result;
3377   return jresult;
3378 }
3379
3380
3381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3382   ushortp *arg1 = (ushortp *) 0 ;
3383
3384   arg1 = (ushortp *)jarg1;
3385   {
3386     try {
3387       delete_ushortp(arg1);
3388     } catch (std::out_of_range& e) {
3389       {
3390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3391       };
3392     } catch (std::exception& e) {
3393       {
3394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3395       };
3396     } catch (Dali::DaliException e) {
3397       {
3398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3399       };
3400     } catch (...) {
3401       {
3402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3403       };
3404     }
3405   }
3406
3407 }
3408
3409
3410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3411   ushortp *arg1 = (ushortp *) 0 ;
3412   unsigned short arg2 ;
3413
3414   arg1 = (ushortp *)jarg1;
3415   arg2 = (unsigned short)jarg2;
3416   {
3417     try {
3418       ushortp_assign(arg1,arg2);
3419     } catch (std::out_of_range& e) {
3420       {
3421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3422       };
3423     } catch (std::exception& e) {
3424       {
3425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3426       };
3427     } catch (Dali::DaliException e) {
3428       {
3429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3430       };
3431     } catch (...) {
3432       {
3433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3434       };
3435     }
3436   }
3437
3438 }
3439
3440
3441 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3442   unsigned short jresult ;
3443   ushortp *arg1 = (ushortp *) 0 ;
3444   unsigned short result;
3445
3446   arg1 = (ushortp *)jarg1;
3447   {
3448     try {
3449       result = (unsigned short)ushortp_value(arg1);
3450     } catch (std::out_of_range& e) {
3451       {
3452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (std::exception& e) {
3455       {
3456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (Dali::DaliException e) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468
3469   jresult = result;
3470   return jresult;
3471 }
3472
3473
3474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3475   void * jresult ;
3476   ushortp *arg1 = (ushortp *) 0 ;
3477   unsigned short *result = 0 ;
3478
3479   arg1 = (ushortp *)jarg1;
3480   {
3481     try {
3482       result = (unsigned short *)ushortp_cast(arg1);
3483     } catch (std::out_of_range& e) {
3484       {
3485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3486       };
3487     } catch (std::exception& e) {
3488       {
3489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3490       };
3491     } catch (Dali::DaliException e) {
3492       {
3493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3494       };
3495     } catch (...) {
3496       {
3497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3498       };
3499     }
3500   }
3501
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3508   void * jresult ;
3509   unsigned short *arg1 = (unsigned short *) 0 ;
3510   ushortp *result = 0 ;
3511
3512   arg1 = (unsigned short *)jarg1;
3513   {
3514     try {
3515       result = (ushortp *)ushortp_frompointer(arg1);
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (Dali::DaliException e) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3527       };
3528     } catch (...) {
3529       {
3530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3531       };
3532     }
3533   }
3534
3535   jresult = (void *)result;
3536   return jresult;
3537 }
3538
3539
3540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3541   unsigned int jresult ;
3542   int arg1 ;
3543   unsigned int result;
3544
3545   arg1 = (int)jarg1;
3546   {
3547     try {
3548       result = (unsigned int)int_to_uint(arg1);
3549     } catch (std::out_of_range& e) {
3550       {
3551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3552       };
3553     } catch (std::exception& e) {
3554       {
3555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3556       };
3557     } catch (Dali::DaliException e) {
3558       {
3559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3560       };
3561     } catch (...) {
3562       {
3563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3564       };
3565     }
3566   }
3567
3568   jresult = result;
3569   return jresult;
3570 }
3571
3572
3573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3574   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3575
3576   arg1 = (Dali::RefObject *)jarg1;
3577   {
3578     try {
3579       (arg1)->Reference();
3580     } catch (std::out_of_range& e) {
3581       {
3582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (std::exception& e) {
3585       {
3586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3587       };
3588     } catch (Dali::DaliException e) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3591       };
3592     } catch (...) {
3593       {
3594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3595       };
3596     }
3597   }
3598
3599 }
3600
3601
3602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3603   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3604
3605   arg1 = (Dali::RefObject *)jarg1;
3606   {
3607     try {
3608       (arg1)->Unreference();
3609     } catch (std::out_of_range& e) {
3610       {
3611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3612       };
3613     } catch (std::exception& e) {
3614       {
3615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3616       };
3617     } catch (Dali::DaliException e) {
3618       {
3619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3620       };
3621     } catch (...) {
3622       {
3623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3624       };
3625     }
3626   }
3627
3628 }
3629
3630
3631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3632   int jresult ;
3633   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3634   int result;
3635
3636   arg1 = (Dali::RefObject *)jarg1;
3637   {
3638     try {
3639       result = (int)(arg1)->ReferenceCount();
3640     } catch (std::out_of_range& e) {
3641       {
3642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3643       };
3644     } catch (std::exception& e) {
3645       {
3646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3647       };
3648     } catch (Dali::DaliException e) {
3649       {
3650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3651       };
3652     } catch (...) {
3653       {
3654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3655       };
3656     }
3657   }
3658
3659   jresult = result;
3660   return jresult;
3661 }
3662
3663
3664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3665   void * jresult ;
3666   Dali::Any *result = 0 ;
3667
3668   {
3669     try {
3670       result = (Dali::Any *)new Dali::Any();
3671     } catch (std::out_of_range& e) {
3672       {
3673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3674       };
3675     } catch (std::exception& e) {
3676       {
3677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3678       };
3679     } catch (Dali::DaliException e) {
3680       {
3681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3682       };
3683     } catch (...) {
3684       {
3685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3686       };
3687     }
3688   }
3689
3690   jresult = (void *)result;
3691   return jresult;
3692 }
3693
3694
3695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3696   Dali::Any *arg1 = (Dali::Any *) 0 ;
3697
3698   arg1 = (Dali::Any *)jarg1;
3699   {
3700     try {
3701       delete arg1;
3702     } catch (std::out_of_range& e) {
3703       {
3704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3705       };
3706     } catch (std::exception& e) {
3707       {
3708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3709       };
3710     } catch (Dali::DaliException e) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3713       };
3714     } catch (...) {
3715       {
3716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3717       };
3718     }
3719   }
3720
3721 }
3722
3723
3724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3725   char *arg1 = (char *) 0 ;
3726
3727   arg1 = (char *)jarg1;
3728   {
3729     try {
3730       Dali::Any::AssertAlways((char const *)arg1);
3731     } catch (std::out_of_range& e) {
3732       {
3733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3734       };
3735     } catch (std::exception& e) {
3736       {
3737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3738       };
3739     } catch (Dali::DaliException e) {
3740       {
3741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3742       };
3743     } catch (...) {
3744       {
3745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3746       };
3747     }
3748   }
3749
3750 }
3751
3752
3753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3754   void * jresult ;
3755   Dali::Any *arg1 = 0 ;
3756   Dali::Any *result = 0 ;
3757
3758   arg1 = (Dali::Any *)jarg1;
3759   if (!arg1) {
3760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3761     return 0;
3762   }
3763   {
3764     try {
3765       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3766     } catch (std::out_of_range& e) {
3767       {
3768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (std::exception& e) {
3771       {
3772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (Dali::DaliException e) {
3775       {
3776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3777       };
3778     } catch (...) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3781       };
3782     }
3783   }
3784
3785   jresult = (void *)result;
3786   return jresult;
3787 }
3788
3789
3790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3791   void * jresult ;
3792   Dali::Any *arg1 = (Dali::Any *) 0 ;
3793   Dali::Any *arg2 = 0 ;
3794   Dali::Any *result = 0 ;
3795
3796   arg1 = (Dali::Any *)jarg1;
3797   arg2 = (Dali::Any *)jarg2;
3798   if (!arg2) {
3799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3800     return 0;
3801   }
3802   {
3803     try {
3804       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (Dali::DaliException e) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3830   void * jresult ;
3831   Dali::Any *arg1 = (Dali::Any *) 0 ;
3832   std::type_info *result = 0 ;
3833
3834   arg1 = (Dali::Any *)jarg1;
3835   {
3836     try {
3837       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3838     } catch (std::out_of_range& e) {
3839       {
3840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3841       };
3842     } catch (std::exception& e) {
3843       {
3844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3845       };
3846     } catch (Dali::DaliException e) {
3847       {
3848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3849       };
3850     } catch (...) {
3851       {
3852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3853       };
3854     }
3855   }
3856
3857   jresult = (void *)result;
3858   return jresult;
3859 }
3860
3861
3862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3863   unsigned int jresult ;
3864   Dali::Any *arg1 = (Dali::Any *) 0 ;
3865   bool result;
3866
3867   arg1 = (Dali::Any *)jarg1;
3868   {
3869     try {
3870       result = (bool)((Dali::Any const *)arg1)->Empty();
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (Dali::DaliException e) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3882       };
3883     } catch (...) {
3884       {
3885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3886       };
3887     }
3888   }
3889
3890   jresult = result;
3891   return jresult;
3892 }
3893
3894
3895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3896   void * jresult ;
3897   std::type_info *arg1 = 0 ;
3898   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3899   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3900   Dali::Any::AnyContainerBase *result = 0 ;
3901
3902   arg1 = (std::type_info *)jarg1;
3903   if (!arg1) {
3904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3905     return 0;
3906   }
3907   arg2 = (Dali::Any::CloneFunc)jarg2;
3908   arg3 = (Dali::Any::DeleteFunc)jarg3;
3909   {
3910     try {
3911       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3912     } catch (std::out_of_range& e) {
3913       {
3914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3915       };
3916     } catch (std::exception& e) {
3917       {
3918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3919       };
3920     } catch (Dali::DaliException e) {
3921       {
3922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3923       };
3924     } catch (...) {
3925       {
3926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3927       };
3928     }
3929   }
3930
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3937   void * jresult ;
3938   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3939   std::type_info *result = 0 ;
3940
3941   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3942   {
3943     try {
3944       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3945     } catch (std::out_of_range& e) {
3946       {
3947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3948       };
3949     } catch (std::exception& e) {
3950       {
3951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3952       };
3953     } catch (Dali::DaliException e) {
3954       {
3955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3956       };
3957     } catch (...) {
3958       {
3959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3960       };
3961     }
3962   }
3963
3964   jresult = (void *)result;
3965   return jresult;
3966 }
3967
3968
3969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3970   void * jresult ;
3971   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3972   ::std::type_info *result = 0 ;
3973
3974   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3975   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3976   jresult = (void *)result;
3977   return jresult;
3978 }
3979
3980
3981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3982   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3983   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3984
3985   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3986   arg2 = (Dali::Any::CloneFunc)jarg2;
3987   if (arg1) (arg1)->mCloneFunc = arg2;
3988 }
3989
3990
3991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3992   void * jresult ;
3993   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3994   Dali::Any::CloneFunc result;
3995
3996   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3997   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3998   jresult = (void *)result;
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4004   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4005   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4006
4007   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4008   arg2 = (Dali::Any::DeleteFunc)jarg2;
4009   if (arg1) (arg1)->mDeleteFunc = arg2;
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4014   void * jresult ;
4015   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4016   Dali::Any::DeleteFunc result;
4017
4018   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4019   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4020   jresult = (void *)result;
4021   return jresult;
4022 }
4023
4024
4025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4026   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4027
4028   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4029   {
4030     try {
4031       delete arg1;
4032     } catch (std::out_of_range& e) {
4033       {
4034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4035       };
4036     } catch (std::exception& e) {
4037       {
4038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4039       };
4040     } catch (Dali::DaliException e) {
4041       {
4042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4043       };
4044     } catch (...) {
4045       {
4046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4047       };
4048     }
4049   }
4050
4051 }
4052
4053
4054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4055   Dali::Any *arg1 = (Dali::Any *) 0 ;
4056   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4057
4058   arg1 = (Dali::Any *)jarg1;
4059   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4060   if (arg1) (arg1)->mContainer = arg2;
4061 }
4062
4063
4064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4065   void * jresult ;
4066   Dali::Any *arg1 = (Dali::Any *) 0 ;
4067   Dali::Any::AnyContainerBase *result = 0 ;
4068
4069   arg1 = (Dali::Any *)jarg1;
4070   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4071   jresult = (void *)result;
4072   return jresult;
4073 }
4074
4075
4076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4077   char *arg1 = (char *) 0 ;
4078   char *arg2 = (char *) 0 ;
4079
4080   arg1 = (char *)jarg1;
4081   arg2 = (char *)jarg2;
4082   {
4083     try {
4084       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4092       };
4093     } catch (Dali::DaliException e) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4096       };
4097     } catch (...) {
4098       {
4099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4100       };
4101     }
4102   }
4103
4104 }
4105
4106
4107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4108   void * jresult ;
4109   char *arg1 = (char *) 0 ;
4110   char *arg2 = (char *) 0 ;
4111   Dali::DaliException *result = 0 ;
4112
4113   arg1 = (char *)jarg1;
4114   arg2 = (char *)jarg2;
4115   {
4116     try {
4117       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4118     } catch (std::out_of_range& e) {
4119       {
4120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4121       };
4122     } catch (std::exception& e) {
4123       {
4124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4125       };
4126     } catch (Dali::DaliException e) {
4127       {
4128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4129       };
4130     } catch (...) {
4131       {
4132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4133       };
4134     }
4135   }
4136
4137   jresult = (void *)result;
4138   return jresult;
4139 }
4140
4141
4142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4143   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4144   std::string arg2 = std::string(jarg2);
4145
4146   arg1 = (Dali::DaliException *)jarg1;
4147   {
4148     if (!arg2.empty()) {
4149       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4150     } else {
4151       arg1->location = 0;
4152     }
4153   }
4154 }
4155
4156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4157   char * jresult ;
4158   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4159   char *result = 0 ;
4160
4161   arg1 = (Dali::DaliException *)jarg1;
4162   result = (char *) ((arg1)->location);
4163   jresult = SWIG_csharp_string_callback((const char *)result);
4164   return jresult;
4165 }
4166
4167
4168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4169   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4170   std::string arg2 = std::string(jarg2);
4171
4172   arg1 = (Dali::DaliException *)jarg1;
4173   {
4174     if (!arg2.empty()) {
4175       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4176     } else {
4177       arg1->condition = 0;
4178     }
4179   }
4180 }
4181
4182
4183 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4184   char * jresult ;
4185   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4186   char *result = 0 ;
4187
4188   arg1 = (Dali::DaliException *)jarg1;
4189   result = (char *) ((arg1)->condition);
4190   jresult = SWIG_csharp_string_callback((const char *)result);
4191   return jresult;
4192 }
4193
4194
4195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4196   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4197
4198   arg1 = (Dali::DaliException *)jarg1;
4199   {
4200     try {
4201       delete arg1;
4202     } catch (std::out_of_range& e) {
4203       {
4204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4205       };
4206     } catch (std::exception& e) {
4207       {
4208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4209       };
4210     } catch (Dali::DaliException e) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4213       };
4214     } catch (...) {
4215       {
4216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4217       };
4218     }
4219   }
4220
4221 }
4222
4223
4224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4225   void * jresult ;
4226   Dali::Vector2 *result = 0 ;
4227
4228   {
4229     try {
4230       result = (Dali::Vector2 *)new Dali::Vector2();
4231     } catch (std::out_of_range& e) {
4232       {
4233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (std::exception& e) {
4236       {
4237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (Dali::DaliException e) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4242       };
4243     } catch (...) {
4244       {
4245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4246       };
4247     }
4248   }
4249
4250   jresult = (void *)result;
4251   return jresult;
4252 }
4253
4254
4255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4256   void * jresult ;
4257   float arg1 ;
4258   float arg2 ;
4259   Dali::Vector2 *result = 0 ;
4260
4261   arg1 = (float)jarg1;
4262   arg2 = (float)jarg2;
4263   {
4264     try {
4265       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4266     } catch (std::out_of_range& e) {
4267       {
4268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (std::exception& e) {
4271       {
4272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4273       };
4274     } catch (Dali::DaliException e) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4277       };
4278     } catch (...) {
4279       {
4280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4281       };
4282     }
4283   }
4284
4285   jresult = (void *)result;
4286   return jresult;
4287 }
4288
4289
4290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4291   void * jresult ;
4292   float *arg1 = (float *) 0 ;
4293   Dali::Vector2 *result = 0 ;
4294
4295   arg1 = jarg1;
4296   {
4297     try {
4298       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4299     } catch (std::out_of_range& e) {
4300       {
4301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (std::exception& e) {
4304       {
4305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4306       };
4307     } catch (Dali::DaliException e) {
4308       {
4309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4310       };
4311     } catch (...) {
4312       {
4313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4314       };
4315     }
4316   }
4317
4318   jresult = (void *)result;
4319
4320
4321   return jresult;
4322 }
4323
4324
4325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4326   void * jresult ;
4327   Dali::Vector3 *arg1 = 0 ;
4328   Dali::Vector2 *result = 0 ;
4329
4330   arg1 = (Dali::Vector3 *)jarg1;
4331   if (!arg1) {
4332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4333     return 0;
4334   }
4335   {
4336     try {
4337       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4338     } catch (std::out_of_range& e) {
4339       {
4340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4341       };
4342     } catch (std::exception& e) {
4343       {
4344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (Dali::DaliException e) {
4347       {
4348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4349       };
4350     } catch (...) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4353       };
4354     }
4355   }
4356
4357   jresult = (void *)result;
4358   return jresult;
4359 }
4360
4361
4362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4363   void * jresult ;
4364   Dali::Vector4 *arg1 = 0 ;
4365   Dali::Vector2 *result = 0 ;
4366
4367   arg1 = (Dali::Vector4 *)jarg1;
4368   if (!arg1) {
4369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4370     return 0;
4371   }
4372   {
4373     try {
4374       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4375     } catch (std::out_of_range& e) {
4376       {
4377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (std::exception& e) {
4380       {
4381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4382       };
4383     } catch (Dali::DaliException e) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4386       };
4387     } catch (...) {
4388       {
4389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4390       };
4391     }
4392   }
4393
4394   jresult = (void *)result;
4395   return jresult;
4396 }
4397
4398
4399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4400   void * jresult ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4404   jresult = (void *)result;
4405   return jresult;
4406 }
4407
4408
4409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4410   void * jresult ;
4411   Dali::Vector2 *result = 0 ;
4412
4413   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4414   jresult = (void *)result;
4415   return jresult;
4416 }
4417
4418
4419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4420   void * jresult ;
4421   Dali::Vector2 *result = 0 ;
4422
4423   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4424   jresult = (void *)result;
4425   return jresult;
4426 }
4427
4428
4429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4430   void * jresult ;
4431   Dali::Vector2 *result = 0 ;
4432
4433   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4434   jresult = (void *)result;
4435   return jresult;
4436 }
4437
4438
4439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4440   void * jresult ;
4441   Dali::Vector2 *result = 0 ;
4442
4443   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4444   jresult = (void *)result;
4445   return jresult;
4446 }
4447
4448
4449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4450   void * jresult ;
4451   Dali::Vector2 *result = 0 ;
4452
4453   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4454   jresult = (void *)result;
4455   return jresult;
4456 }
4457
4458
4459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4460   void * jresult ;
4461   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4462   float *arg2 = (float *) 0 ;
4463   Dali::Vector2 *result = 0 ;
4464
4465   arg1 = (Dali::Vector2 *)jarg1;
4466   arg2 = jarg2;
4467   {
4468     try {
4469       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4470     } catch (std::out_of_range& e) {
4471       {
4472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4473       };
4474     } catch (std::exception& e) {
4475       {
4476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4477       };
4478     } catch (Dali::DaliException e) {
4479       {
4480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4481       };
4482     } catch (...) {
4483       {
4484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4485       };
4486     }
4487   }
4488
4489   jresult = (void *)result;
4490
4491
4492   return jresult;
4493 }
4494
4495
4496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4497   void * jresult ;
4498   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4499   Dali::Vector3 *arg2 = 0 ;
4500   Dali::Vector2 *result = 0 ;
4501
4502   arg1 = (Dali::Vector2 *)jarg1;
4503   arg2 = (Dali::Vector3 *)jarg2;
4504   if (!arg2) {
4505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4506     return 0;
4507   }
4508   {
4509     try {
4510       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4511     } catch (std::out_of_range& e) {
4512       {
4513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4514       };
4515     } catch (std::exception& e) {
4516       {
4517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4518       };
4519     } catch (Dali::DaliException e) {
4520       {
4521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4522       };
4523     } catch (...) {
4524       {
4525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4526       };
4527     }
4528   }
4529
4530   jresult = (void *)result;
4531   return jresult;
4532 }
4533
4534
4535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4536   void * jresult ;
4537   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4538   Dali::Vector4 *arg2 = 0 ;
4539   Dali::Vector2 *result = 0 ;
4540
4541   arg1 = (Dali::Vector2 *)jarg1;
4542   arg2 = (Dali::Vector4 *)jarg2;
4543   if (!arg2) {
4544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4545     return 0;
4546   }
4547   {
4548     try {
4549       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4550     } catch (std::out_of_range& e) {
4551       {
4552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (std::exception& e) {
4555       {
4556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4557       };
4558     } catch (Dali::DaliException e) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4561       };
4562     } catch (...) {
4563       {
4564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4565       };
4566     }
4567   }
4568
4569   jresult = (void *)result;
4570   return jresult;
4571 }
4572
4573
4574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4575   void * jresult ;
4576   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4577   Dali::Vector2 *arg2 = 0 ;
4578   Dali::Vector2 result;
4579
4580   arg1 = (Dali::Vector2 *)jarg1;
4581   arg2 = (Dali::Vector2 *)jarg2;
4582   if (!arg2) {
4583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4584     return 0;
4585   }
4586   {
4587     try {
4588       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4589     } catch (std::out_of_range& e) {
4590       {
4591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4592       };
4593     } catch (std::exception& e) {
4594       {
4595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4596       };
4597     } catch (Dali::DaliException e) {
4598       {
4599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4600       };
4601     } catch (...) {
4602       {
4603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4604       };
4605     }
4606   }
4607
4608   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4609   return jresult;
4610 }
4611
4612
4613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4614   void * jresult ;
4615   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4616   Dali::Vector2 *arg2 = 0 ;
4617   Dali::Vector2 *result = 0 ;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   arg2 = (Dali::Vector2 *)jarg2;
4621   if (!arg2) {
4622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4623     return 0;
4624   }
4625   {
4626     try {
4627       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4628     } catch (std::out_of_range& e) {
4629       {
4630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (std::exception& e) {
4633       {
4634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (Dali::DaliException e) {
4637       {
4638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4643       };
4644     }
4645   }
4646
4647   jresult = (void *)result;
4648   return jresult;
4649 }
4650
4651
4652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4653   void * jresult ;
4654   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4655   Dali::Vector2 *arg2 = 0 ;
4656   Dali::Vector2 result;
4657
4658   arg1 = (Dali::Vector2 *)jarg1;
4659   arg2 = (Dali::Vector2 *)jarg2;
4660   if (!arg2) {
4661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4662     return 0;
4663   }
4664   {
4665     try {
4666       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4667     } catch (std::out_of_range& e) {
4668       {
4669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4670       };
4671     } catch (std::exception& e) {
4672       {
4673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4674       };
4675     } catch (Dali::DaliException e) {
4676       {
4677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4678       };
4679     } catch (...) {
4680       {
4681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4682       };
4683     }
4684   }
4685
4686   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4692   void * jresult ;
4693   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4694   Dali::Vector2 *arg2 = 0 ;
4695   Dali::Vector2 *result = 0 ;
4696
4697   arg1 = (Dali::Vector2 *)jarg1;
4698   arg2 = (Dali::Vector2 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4701     return 0;
4702   }
4703   {
4704     try {
4705       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4706     } catch (std::out_of_range& e) {
4707       {
4708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4709       };
4710     } catch (std::exception& e) {
4711       {
4712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4713       };
4714     } catch (Dali::DaliException e) {
4715       {
4716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4717       };
4718     } catch (...) {
4719       {
4720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4721       };
4722     }
4723   }
4724
4725   jresult = (void *)result;
4726   return jresult;
4727 }
4728
4729
4730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4731   void * jresult ;
4732   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4733   Dali::Vector2 *arg2 = 0 ;
4734   Dali::Vector2 result;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   arg2 = (Dali::Vector2 *)jarg2;
4738   if (!arg2) {
4739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4740     return 0;
4741   }
4742   {
4743     try {
4744       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4745     } catch (std::out_of_range& e) {
4746       {
4747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4748       };
4749     } catch (std::exception& e) {
4750       {
4751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4752       };
4753     } catch (Dali::DaliException e) {
4754       {
4755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4756       };
4757     } catch (...) {
4758       {
4759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4760       };
4761     }
4762   }
4763
4764   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4765   return jresult;
4766 }
4767
4768
4769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4770   void * jresult ;
4771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4772   float arg2 ;
4773   Dali::Vector2 result;
4774
4775   arg1 = (Dali::Vector2 *)jarg1;
4776   arg2 = (float)jarg2;
4777   {
4778     try {
4779       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4780     } catch (std::out_of_range& e) {
4781       {
4782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4783       };
4784     } catch (std::exception& e) {
4785       {
4786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4787       };
4788     } catch (Dali::DaliException e) {
4789       {
4790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4791       };
4792     } catch (...) {
4793       {
4794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4795       };
4796     }
4797   }
4798
4799   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4800   return jresult;
4801 }
4802
4803
4804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4805   void * jresult ;
4806   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4807   Dali::Vector2 *arg2 = 0 ;
4808   Dali::Vector2 *result = 0 ;
4809
4810   arg1 = (Dali::Vector2 *)jarg1;
4811   arg2 = (Dali::Vector2 *)jarg2;
4812   if (!arg2) {
4813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4814     return 0;
4815   }
4816   {
4817     try {
4818       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4819     } catch (std::out_of_range& e) {
4820       {
4821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4822       };
4823     } catch (std::exception& e) {
4824       {
4825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4826       };
4827     } catch (Dali::DaliException e) {
4828       {
4829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4830       };
4831     } catch (...) {
4832       {
4833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4834       };
4835     }
4836   }
4837
4838   jresult = (void *)result;
4839   return jresult;
4840 }
4841
4842
4843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4844   void * jresult ;
4845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4846   float arg2 ;
4847   Dali::Vector2 *result = 0 ;
4848
4849   arg1 = (Dali::Vector2 *)jarg1;
4850   arg2 = (float)jarg2;
4851   {
4852     try {
4853       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4854     } catch (std::out_of_range& e) {
4855       {
4856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4857       };
4858     } catch (std::exception& e) {
4859       {
4860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4861       };
4862     } catch (Dali::DaliException e) {
4863       {
4864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4865       };
4866     } catch (...) {
4867       {
4868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4869       };
4870     }
4871   }
4872
4873   jresult = (void *)result;
4874   return jresult;
4875 }
4876
4877
4878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4879   void * jresult ;
4880   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4881   Dali::Vector2 *arg2 = 0 ;
4882   Dali::Vector2 result;
4883
4884   arg1 = (Dali::Vector2 *)jarg1;
4885   arg2 = (Dali::Vector2 *)jarg2;
4886   if (!arg2) {
4887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4888     return 0;
4889   }
4890   {
4891     try {
4892       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4893     } catch (std::out_of_range& e) {
4894       {
4895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (std::exception& e) {
4898       {
4899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4900       };
4901     } catch (Dali::DaliException e) {
4902       {
4903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4904       };
4905     } catch (...) {
4906       {
4907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4908       };
4909     }
4910   }
4911
4912   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4913   return jresult;
4914 }
4915
4916
4917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4918   void * jresult ;
4919   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4920   float arg2 ;
4921   Dali::Vector2 result;
4922
4923   arg1 = (Dali::Vector2 *)jarg1;
4924   arg2 = (float)jarg2;
4925   {
4926     try {
4927       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4928     } catch (std::out_of_range& e) {
4929       {
4930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4931       };
4932     } catch (std::exception& e) {
4933       {
4934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4935       };
4936     } catch (Dali::DaliException e) {
4937       {
4938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4939       };
4940     } catch (...) {
4941       {
4942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4943       };
4944     }
4945   }
4946
4947   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4948   return jresult;
4949 }
4950
4951
4952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4953   void * jresult ;
4954   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4955   Dali::Vector2 *arg2 = 0 ;
4956   Dali::Vector2 *result = 0 ;
4957
4958   arg1 = (Dali::Vector2 *)jarg1;
4959   arg2 = (Dali::Vector2 *)jarg2;
4960   if (!arg2) {
4961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4962     return 0;
4963   }
4964   {
4965     try {
4966       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (Dali::DaliException e) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4978       };
4979     } catch (...) {
4980       {
4981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4982       };
4983     }
4984   }
4985
4986   jresult = (void *)result;
4987   return jresult;
4988 }
4989
4990
4991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4992   void * jresult ;
4993   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4994   float arg2 ;
4995   Dali::Vector2 *result = 0 ;
4996
4997   arg1 = (Dali::Vector2 *)jarg1;
4998   arg2 = (float)jarg2;
4999   {
5000     try {
5001       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5002     } catch (std::out_of_range& e) {
5003       {
5004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (std::exception& e) {
5007       {
5008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (Dali::DaliException e) {
5011       {
5012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5013       };
5014     } catch (...) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5017       };
5018     }
5019   }
5020
5021   jresult = (void *)result;
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5027   void * jresult ;
5028   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5029   Dali::Vector2 result;
5030
5031   arg1 = (Dali::Vector2 *)jarg1;
5032   {
5033     try {
5034       result = ((Dali::Vector2 const *)arg1)->operator -();
5035     } catch (std::out_of_range& e) {
5036       {
5037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5038       };
5039     } catch (std::exception& e) {
5040       {
5041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (Dali::DaliException e) {
5044       {
5045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5046       };
5047     } catch (...) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5050       };
5051     }
5052   }
5053
5054   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5055   return jresult;
5056 }
5057
5058
5059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5060   unsigned int jresult ;
5061   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5062   Dali::Vector2 *arg2 = 0 ;
5063   bool result;
5064
5065   arg1 = (Dali::Vector2 *)jarg1;
5066   arg2 = (Dali::Vector2 *)jarg2;
5067   if (!arg2) {
5068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5069     return 0;
5070   }
5071   {
5072     try {
5073       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5074     } catch (std::out_of_range& e) {
5075       {
5076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (std::exception& e) {
5079       {
5080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5081       };
5082     } catch (Dali::DaliException e) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5085       };
5086     } catch (...) {
5087       {
5088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5089       };
5090     }
5091   }
5092
5093   jresult = result;
5094   return jresult;
5095 }
5096
5097
5098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5099   unsigned int jresult ;
5100   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5101   Dali::Vector2 *arg2 = 0 ;
5102   bool result;
5103
5104   arg1 = (Dali::Vector2 *)jarg1;
5105   arg2 = (Dali::Vector2 *)jarg2;
5106   if (!arg2) {
5107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5108     return 0;
5109   }
5110   {
5111     try {
5112       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5113     } catch (std::out_of_range& e) {
5114       {
5115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5116       };
5117     } catch (std::exception& e) {
5118       {
5119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5120       };
5121     } catch (Dali::DaliException e) {
5122       {
5123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5124       };
5125     } catch (...) {
5126       {
5127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5128       };
5129     }
5130   }
5131
5132   jresult = result;
5133   return jresult;
5134 }
5135
5136
5137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5138   float jresult ;
5139   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5140   unsigned int arg2 ;
5141   float *result = 0 ;
5142
5143   arg1 = (Dali::Vector2 *)jarg1;
5144   arg2 = (unsigned int)jarg2;
5145   {
5146     try {
5147       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5148     } catch (std::out_of_range& e) {
5149       {
5150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (std::exception& e) {
5153       {
5154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (Dali::DaliException e) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5159       };
5160     } catch (...) {
5161       {
5162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5163       };
5164     }
5165   }
5166
5167   jresult = *result;
5168   return jresult;
5169 }
5170
5171
5172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5173   float jresult ;
5174   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5175   float result;
5176
5177   arg1 = (Dali::Vector2 *)jarg1;
5178   {
5179     try {
5180       result = (float)((Dali::Vector2 const *)arg1)->Length();
5181     } catch (std::out_of_range& e) {
5182       {
5183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (std::exception& e) {
5186       {
5187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (Dali::DaliException e) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199
5200   jresult = result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5206   float jresult ;
5207   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5208   float result;
5209
5210   arg1 = (Dali::Vector2 *)jarg1;
5211   {
5212     try {
5213       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5214     } catch (std::out_of_range& e) {
5215       {
5216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5217       };
5218     } catch (std::exception& e) {
5219       {
5220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5221       };
5222     } catch (Dali::DaliException e) {
5223       {
5224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5225       };
5226     } catch (...) {
5227       {
5228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5229       };
5230     }
5231   }
5232
5233   jresult = result;
5234   return jresult;
5235 }
5236
5237
5238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5239   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5240
5241   arg1 = (Dali::Vector2 *)jarg1;
5242   {
5243     try {
5244       (arg1)->Normalize();
5245     } catch (std::out_of_range& e) {
5246       {
5247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5248       };
5249     } catch (std::exception& e) {
5250       {
5251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5252       };
5253     } catch (Dali::DaliException e) {
5254       {
5255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5256       };
5257     } catch (...) {
5258       {
5259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5260       };
5261     }
5262   }
5263
5264 }
5265
5266
5267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5268   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5269   Dali::Vector2 *arg2 = 0 ;
5270   Dali::Vector2 *arg3 = 0 ;
5271
5272   arg1 = (Dali::Vector2 *)jarg1;
5273   arg2 = (Dali::Vector2 *)jarg2;
5274   if (!arg2) {
5275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5276     return ;
5277   }
5278   arg3 = (Dali::Vector2 *)jarg3;
5279   if (!arg3) {
5280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5281     return ;
5282   }
5283   {
5284     try {
5285       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5286     } catch (std::out_of_range& e) {
5287       {
5288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5289       };
5290     } catch (std::exception& e) {
5291       {
5292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5293       };
5294     } catch (Dali::DaliException e) {
5295       {
5296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5297       };
5298     } catch (...) {
5299       {
5300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5301       };
5302     }
5303   }
5304
5305 }
5306
5307
5308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5309   void * jresult ;
5310   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5311   float *result = 0 ;
5312
5313   arg1 = (Dali::Vector2 *)jarg1;
5314   {
5315     try {
5316       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5317     } catch (std::out_of_range& e) {
5318       {
5319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5320       };
5321     } catch (std::exception& e) {
5322       {
5323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5324       };
5325     } catch (Dali::DaliException e) {
5326       {
5327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5328       };
5329     } catch (...) {
5330       {
5331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5332       };
5333     }
5334   }
5335
5336   jresult = (void *)result;
5337   return jresult;
5338 }
5339
5340
5341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5342   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5343   float arg2 ;
5344
5345   arg1 = (Dali::Vector2 *)jarg1;
5346   arg2 = (float)jarg2;
5347   if (arg1) (arg1)->x = arg2;
5348 }
5349
5350
5351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5352   float jresult ;
5353   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5354   float result;
5355
5356   arg1 = (Dali::Vector2 *)jarg1;
5357   result = (float) ((arg1)->x);
5358   jresult = result;
5359   return jresult;
5360 }
5361
5362
5363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5364   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5365   float arg2 ;
5366
5367   arg1 = (Dali::Vector2 *)jarg1;
5368   arg2 = (float)jarg2;
5369   if (arg1) (arg1)->width = arg2;
5370 }
5371
5372
5373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5374   float jresult ;
5375   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5376   float result;
5377
5378   arg1 = (Dali::Vector2 *)jarg1;
5379   result = (float) ((arg1)->width);
5380   jresult = result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5386   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5387   float arg2 ;
5388
5389   arg1 = (Dali::Vector2 *)jarg1;
5390   arg2 = (float)jarg2;
5391   if (arg1) (arg1)->y = arg2;
5392 }
5393
5394
5395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5396   float jresult ;
5397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5398   float result;
5399
5400   arg1 = (Dali::Vector2 *)jarg1;
5401   result = (float) ((arg1)->y);
5402   jresult = result;
5403   return jresult;
5404 }
5405
5406
5407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5408   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5409   float arg2 ;
5410
5411   arg1 = (Dali::Vector2 *)jarg1;
5412   arg2 = (float)jarg2;
5413   if (arg1) (arg1)->height = arg2;
5414 }
5415
5416
5417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5418   float jresult ;
5419   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5420   float result;
5421
5422   arg1 = (Dali::Vector2 *)jarg1;
5423   result = (float) ((arg1)->height);
5424   jresult = result;
5425   return jresult;
5426 }
5427
5428
5429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5430   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5431
5432   arg1 = (Dali::Vector2 *)jarg1;
5433   {
5434     try {
5435       delete arg1;
5436     } catch (std::out_of_range& e) {
5437       {
5438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5439       };
5440     } catch (std::exception& e) {
5441       {
5442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5443       };
5444     } catch (Dali::DaliException e) {
5445       {
5446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5447       };
5448     } catch (...) {
5449       {
5450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5451       };
5452     }
5453   }
5454
5455 }
5456
5457
5458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5459   void * jresult ;
5460   Dali::Vector2 *arg1 = 0 ;
5461   Dali::Vector2 *arg2 = 0 ;
5462   Dali::Vector2 result;
5463
5464   arg1 = (Dali::Vector2 *)jarg1;
5465   if (!arg1) {
5466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5467     return 0;
5468   }
5469   arg2 = (Dali::Vector2 *)jarg2;
5470   if (!arg2) {
5471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5472     return 0;
5473   }
5474   {
5475     try {
5476       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5477     } catch (std::out_of_range& e) {
5478       {
5479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5480       };
5481     } catch (std::exception& e) {
5482       {
5483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5484       };
5485     } catch (Dali::DaliException e) {
5486       {
5487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5488       };
5489     } catch (...) {
5490       {
5491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5492       };
5493     }
5494   }
5495
5496   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector2 *arg1 = 0 ;
5504   Dali::Vector2 *arg2 = 0 ;
5505   Dali::Vector2 result;
5506
5507   arg1 = (Dali::Vector2 *)jarg1;
5508   if (!arg1) {
5509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5510     return 0;
5511   }
5512   arg2 = (Dali::Vector2 *)jarg2;
5513   if (!arg2) {
5514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5515     return 0;
5516   }
5517   {
5518     try {
5519       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5520     } catch (std::out_of_range& e) {
5521       {
5522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (std::exception& e) {
5525       {
5526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5527       };
5528     } catch (Dali::DaliException e) {
5529       {
5530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5531       };
5532     } catch (...) {
5533       {
5534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5535       };
5536     }
5537   }
5538
5539   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5540   return jresult;
5541 }
5542
5543
5544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5545   void * jresult ;
5546   Dali::Vector2 *arg1 = 0 ;
5547   float *arg2 = 0 ;
5548   float *arg3 = 0 ;
5549   float temp2 ;
5550   float temp3 ;
5551   Dali::Vector2 result;
5552
5553   arg1 = (Dali::Vector2 *)jarg1;
5554   if (!arg1) {
5555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5556     return 0;
5557   }
5558   temp2 = (float)jarg2;
5559   arg2 = &temp2;
5560   temp3 = (float)jarg3;
5561   arg3 = &temp3;
5562   {
5563     try {
5564       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5565     } catch (std::out_of_range& e) {
5566       {
5567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5568       };
5569     } catch (std::exception& e) {
5570       {
5571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5572       };
5573     } catch (Dali::DaliException e) {
5574       {
5575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5576       };
5577     } catch (...) {
5578       {
5579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5580       };
5581     }
5582   }
5583
5584   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5590   void * jresult ;
5591   Dali::Vector3 *result = 0 ;
5592
5593   {
5594     try {
5595       result = (Dali::Vector3 *)new Dali::Vector3();
5596     } catch (std::out_of_range& e) {
5597       {
5598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (std::exception& e) {
5601       {
5602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (Dali::DaliException e) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5607       };
5608     } catch (...) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5611       };
5612     }
5613   }
5614
5615   jresult = (void *)result;
5616   return jresult;
5617 }
5618
5619
5620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5621   void * jresult ;
5622   float arg1 ;
5623   float arg2 ;
5624   float arg3 ;
5625   Dali::Vector3 *result = 0 ;
5626
5627   arg1 = (float)jarg1;
5628   arg2 = (float)jarg2;
5629   arg3 = (float)jarg3;
5630   {
5631     try {
5632       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5633     } catch (std::out_of_range& e) {
5634       {
5635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (std::exception& e) {
5638       {
5639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5640       };
5641     } catch (Dali::DaliException e) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5644       };
5645     } catch (...) {
5646       {
5647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5648       };
5649     }
5650   }
5651
5652   jresult = (void *)result;
5653   return jresult;
5654 }
5655
5656
5657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5658   void * jresult ;
5659   float *arg1 = (float *) 0 ;
5660   Dali::Vector3 *result = 0 ;
5661
5662   arg1 = jarg1;
5663   {
5664     try {
5665       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5666     } catch (std::out_of_range& e) {
5667       {
5668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (std::exception& e) {
5671       {
5672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5673       };
5674     } catch (Dali::DaliException e) {
5675       {
5676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5677       };
5678     } catch (...) {
5679       {
5680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5681       };
5682     }
5683   }
5684
5685   jresult = (void *)result;
5686
5687
5688   return jresult;
5689 }
5690
5691
5692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5693   void * jresult ;
5694   Dali::Vector2 *arg1 = 0 ;
5695   Dali::Vector3 *result = 0 ;
5696
5697   arg1 = (Dali::Vector2 *)jarg1;
5698   if (!arg1) {
5699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5700     return 0;
5701   }
5702   {
5703     try {
5704       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5705     } catch (std::out_of_range& e) {
5706       {
5707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5708       };
5709     } catch (std::exception& e) {
5710       {
5711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (Dali::DaliException e) {
5714       {
5715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5716       };
5717     } catch (...) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5720       };
5721     }
5722   }
5723
5724   jresult = (void *)result;
5725   return jresult;
5726 }
5727
5728
5729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5730   void * jresult ;
5731   Dali::Vector4 *arg1 = 0 ;
5732   Dali::Vector3 *result = 0 ;
5733
5734   arg1 = (Dali::Vector4 *)jarg1;
5735   if (!arg1) {
5736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5737     return 0;
5738   }
5739   {
5740     try {
5741       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5742     } catch (std::out_of_range& e) {
5743       {
5744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (std::exception& e) {
5747       {
5748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5749       };
5750     } catch (Dali::DaliException e) {
5751       {
5752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5753       };
5754     } catch (...) {
5755       {
5756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5757       };
5758     }
5759   }
5760
5761   jresult = (void *)result;
5762   return jresult;
5763 }
5764
5765
5766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5767   void * jresult ;
5768   Dali::Vector3 *result = 0 ;
5769
5770   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5771   jresult = (void *)result;
5772   return jresult;
5773 }
5774
5775
5776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5777   void * jresult ;
5778   Dali::Vector3 *result = 0 ;
5779
5780   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5781   jresult = (void *)result;
5782   return jresult;
5783 }
5784
5785
5786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5787   void * jresult ;
5788   Dali::Vector3 *result = 0 ;
5789
5790   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5797   void * jresult ;
5798   Dali::Vector3 *result = 0 ;
5799
5800   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5801   jresult = (void *)result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5807   void * jresult ;
5808   Dali::Vector3 *result = 0 ;
5809
5810   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5811   jresult = (void *)result;
5812   return jresult;
5813 }
5814
5815
5816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5817   void * jresult ;
5818   Dali::Vector3 *result = 0 ;
5819
5820   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5821   jresult = (void *)result;
5822   return jresult;
5823 }
5824
5825
5826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5827   void * jresult ;
5828   Dali::Vector3 *result = 0 ;
5829
5830   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5831   jresult = (void *)result;
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5837   void * jresult ;
5838   Dali::Vector3 *result = 0 ;
5839
5840   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5841   jresult = (void *)result;
5842   return jresult;
5843 }
5844
5845
5846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5847   void * jresult ;
5848   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5849   float *arg2 = (float *) 0 ;
5850   Dali::Vector3 *result = 0 ;
5851
5852   arg1 = (Dali::Vector3 *)jarg1;
5853   arg2 = jarg2;
5854   {
5855     try {
5856       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5857     } catch (std::out_of_range& e) {
5858       {
5859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5860       };
5861     } catch (std::exception& e) {
5862       {
5863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5864       };
5865     } catch (Dali::DaliException e) {
5866       {
5867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5868       };
5869     } catch (...) {
5870       {
5871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5872       };
5873     }
5874   }
5875
5876   jresult = (void *)result;
5877
5878
5879   return jresult;
5880 }
5881
5882
5883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5884   void * jresult ;
5885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5886   Dali::Vector2 *arg2 = 0 ;
5887   Dali::Vector3 *result = 0 ;
5888
5889   arg1 = (Dali::Vector3 *)jarg1;
5890   arg2 = (Dali::Vector2 *)jarg2;
5891   if (!arg2) {
5892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5893     return 0;
5894   }
5895   {
5896     try {
5897       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5898     } catch (std::out_of_range& e) {
5899       {
5900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5901       };
5902     } catch (std::exception& e) {
5903       {
5904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5905       };
5906     } catch (Dali::DaliException e) {
5907       {
5908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5909       };
5910     } catch (...) {
5911       {
5912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5913       };
5914     }
5915   }
5916
5917   jresult = (void *)result;
5918   return jresult;
5919 }
5920
5921
5922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5923   void * jresult ;
5924   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5925   Dali::Vector4 *arg2 = 0 ;
5926   Dali::Vector3 *result = 0 ;
5927
5928   arg1 = (Dali::Vector3 *)jarg1;
5929   arg2 = (Dali::Vector4 *)jarg2;
5930   if (!arg2) {
5931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5932     return 0;
5933   }
5934   {
5935     try {
5936       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5937     } catch (std::out_of_range& e) {
5938       {
5939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (std::exception& e) {
5942       {
5943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5944       };
5945     } catch (Dali::DaliException e) {
5946       {
5947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5948       };
5949     } catch (...) {
5950       {
5951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5952       };
5953     }
5954   }
5955
5956   jresult = (void *)result;
5957   return jresult;
5958 }
5959
5960
5961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5962   void * jresult ;
5963   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5964   Dali::Vector3 *arg2 = 0 ;
5965   Dali::Vector3 result;
5966
5967   arg1 = (Dali::Vector3 *)jarg1;
5968   arg2 = (Dali::Vector3 *)jarg2;
5969   if (!arg2) {
5970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5971     return 0;
5972   }
5973   {
5974     try {
5975       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5976     } catch (std::out_of_range& e) {
5977       {
5978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (std::exception& e) {
5981       {
5982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5983       };
5984     } catch (Dali::DaliException e) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5987       };
5988     } catch (...) {
5989       {
5990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5991       };
5992     }
5993   }
5994
5995   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5996   return jresult;
5997 }
5998
5999
6000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6001   void * jresult ;
6002   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6003   Dali::Vector3 *arg2 = 0 ;
6004   Dali::Vector3 *result = 0 ;
6005
6006   arg1 = (Dali::Vector3 *)jarg1;
6007   arg2 = (Dali::Vector3 *)jarg2;
6008   if (!arg2) {
6009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6010     return 0;
6011   }
6012   {
6013     try {
6014       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6015     } catch (std::out_of_range& e) {
6016       {
6017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6018       };
6019     } catch (std::exception& e) {
6020       {
6021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6022       };
6023     } catch (Dali::DaliException e) {
6024       {
6025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6026       };
6027     } catch (...) {
6028       {
6029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6030       };
6031     }
6032   }
6033
6034   jresult = (void *)result;
6035   return jresult;
6036 }
6037
6038
6039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6040   void * jresult ;
6041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6042   Dali::Vector3 *arg2 = 0 ;
6043   Dali::Vector3 result;
6044
6045   arg1 = (Dali::Vector3 *)jarg1;
6046   arg2 = (Dali::Vector3 *)jarg2;
6047   if (!arg2) {
6048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6049     return 0;
6050   }
6051   {
6052     try {
6053       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6054     } catch (std::out_of_range& e) {
6055       {
6056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6057       };
6058     } catch (std::exception& e) {
6059       {
6060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6061       };
6062     } catch (Dali::DaliException e) {
6063       {
6064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6065       };
6066     } catch (...) {
6067       {
6068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6069       };
6070     }
6071   }
6072
6073   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6074   return jresult;
6075 }
6076
6077
6078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6079   void * jresult ;
6080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6081   Dali::Vector3 *arg2 = 0 ;
6082   Dali::Vector3 *result = 0 ;
6083
6084   arg1 = (Dali::Vector3 *)jarg1;
6085   arg2 = (Dali::Vector3 *)jarg2;
6086   if (!arg2) {
6087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6088     return 0;
6089   }
6090   {
6091     try {
6092       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6093     } catch (std::out_of_range& e) {
6094       {
6095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6096       };
6097     } catch (std::exception& e) {
6098       {
6099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6100       };
6101     } catch (Dali::DaliException e) {
6102       {
6103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6104       };
6105     } catch (...) {
6106       {
6107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6108       };
6109     }
6110   }
6111
6112   jresult = (void *)result;
6113   return jresult;
6114 }
6115
6116
6117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6118   void * jresult ;
6119   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6120   Dali::Vector3 *arg2 = 0 ;
6121   Dali::Vector3 result;
6122
6123   arg1 = (Dali::Vector3 *)jarg1;
6124   arg2 = (Dali::Vector3 *)jarg2;
6125   if (!arg2) {
6126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6127     return 0;
6128   }
6129   {
6130     try {
6131       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6132     } catch (std::out_of_range& e) {
6133       {
6134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6135       };
6136     } catch (std::exception& e) {
6137       {
6138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6139       };
6140     } catch (Dali::DaliException e) {
6141       {
6142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6143       };
6144     } catch (...) {
6145       {
6146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6147       };
6148     }
6149   }
6150
6151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6152   return jresult;
6153 }
6154
6155
6156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6157   void * jresult ;
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float arg2 ;
6160   Dali::Vector3 result;
6161
6162   arg1 = (Dali::Vector3 *)jarg1;
6163   arg2 = (float)jarg2;
6164   {
6165     try {
6166       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6167     } catch (std::out_of_range& e) {
6168       {
6169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6170       };
6171     } catch (std::exception& e) {
6172       {
6173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6174       };
6175     } catch (Dali::DaliException e) {
6176       {
6177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6178       };
6179     } catch (...) {
6180       {
6181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6182       };
6183     }
6184   }
6185
6186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6192   void * jresult ;
6193   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6194   Dali::Vector3 *arg2 = 0 ;
6195   Dali::Vector3 *result = 0 ;
6196
6197   arg1 = (Dali::Vector3 *)jarg1;
6198   arg2 = (Dali::Vector3 *)jarg2;
6199   if (!arg2) {
6200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6201     return 0;
6202   }
6203   {
6204     try {
6205       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6206     } catch (std::out_of_range& e) {
6207       {
6208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6209       };
6210     } catch (std::exception& e) {
6211       {
6212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6213       };
6214     } catch (Dali::DaliException e) {
6215       {
6216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6217       };
6218     } catch (...) {
6219       {
6220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6221       };
6222     }
6223   }
6224
6225   jresult = (void *)result;
6226   return jresult;
6227 }
6228
6229
6230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6231   void * jresult ;
6232   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6233   float arg2 ;
6234   Dali::Vector3 *result = 0 ;
6235
6236   arg1 = (Dali::Vector3 *)jarg1;
6237   arg2 = (float)jarg2;
6238   {
6239     try {
6240       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6241     } catch (std::out_of_range& e) {
6242       {
6243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6244       };
6245     } catch (std::exception& e) {
6246       {
6247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6248       };
6249     } catch (Dali::DaliException e) {
6250       {
6251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6252       };
6253     } catch (...) {
6254       {
6255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6256       };
6257     }
6258   }
6259
6260   jresult = (void *)result;
6261   return jresult;
6262 }
6263
6264
6265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6266   void * jresult ;
6267   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6268   Dali::Quaternion *arg2 = 0 ;
6269   Dali::Vector3 *result = 0 ;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   arg2 = (Dali::Quaternion *)jarg2;
6273   if (!arg2) {
6274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6275     return 0;
6276   }
6277   {
6278     try {
6279       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6280     } catch (std::out_of_range& e) {
6281       {
6282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6283       };
6284     } catch (std::exception& e) {
6285       {
6286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6287       };
6288     } catch (Dali::DaliException e) {
6289       {
6290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6291       };
6292     } catch (...) {
6293       {
6294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6295       };
6296     }
6297   }
6298
6299   jresult = (void *)result;
6300   return jresult;
6301 }
6302
6303
6304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6305   void * jresult ;
6306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6307   Dali::Vector3 *arg2 = 0 ;
6308   Dali::Vector3 result;
6309
6310   arg1 = (Dali::Vector3 *)jarg1;
6311   arg2 = (Dali::Vector3 *)jarg2;
6312   if (!arg2) {
6313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6314     return 0;
6315   }
6316   {
6317     try {
6318       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6319     } catch (std::out_of_range& e) {
6320       {
6321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6322       };
6323     } catch (std::exception& e) {
6324       {
6325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6326       };
6327     } catch (Dali::DaliException e) {
6328       {
6329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6330       };
6331     } catch (...) {
6332       {
6333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6334       };
6335     }
6336   }
6337
6338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6339   return jresult;
6340 }
6341
6342
6343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6344   void * jresult ;
6345   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6346   float arg2 ;
6347   Dali::Vector3 result;
6348
6349   arg1 = (Dali::Vector3 *)jarg1;
6350   arg2 = (float)jarg2;
6351   {
6352     try {
6353       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6354     } catch (std::out_of_range& e) {
6355       {
6356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6357       };
6358     } catch (std::exception& e) {
6359       {
6360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6361       };
6362     } catch (Dali::DaliException e) {
6363       {
6364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6365       };
6366     } catch (...) {
6367       {
6368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6369       };
6370     }
6371   }
6372
6373   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6374   return jresult;
6375 }
6376
6377
6378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6379   void * jresult ;
6380   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6381   Dali::Vector3 *arg2 = 0 ;
6382   Dali::Vector3 *result = 0 ;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   arg2 = (Dali::Vector3 *)jarg2;
6386   if (!arg2) {
6387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6388     return 0;
6389   }
6390   {
6391     try {
6392       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6393     } catch (std::out_of_range& e) {
6394       {
6395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6396       };
6397     } catch (std::exception& e) {
6398       {
6399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6400       };
6401     } catch (Dali::DaliException e) {
6402       {
6403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6404       };
6405     } catch (...) {
6406       {
6407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6408       };
6409     }
6410   }
6411
6412   jresult = (void *)result;
6413   return jresult;
6414 }
6415
6416
6417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6418   void * jresult ;
6419   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6420   float arg2 ;
6421   Dali::Vector3 *result = 0 ;
6422
6423   arg1 = (Dali::Vector3 *)jarg1;
6424   arg2 = (float)jarg2;
6425   {
6426     try {
6427       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6428     } catch (std::out_of_range& e) {
6429       {
6430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6431       };
6432     } catch (std::exception& e) {
6433       {
6434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6435       };
6436     } catch (Dali::DaliException e) {
6437       {
6438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6439       };
6440     } catch (...) {
6441       {
6442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6443       };
6444     }
6445   }
6446
6447   jresult = (void *)result;
6448   return jresult;
6449 }
6450
6451
6452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6453   void * jresult ;
6454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6455   Dali::Vector3 result;
6456
6457   arg1 = (Dali::Vector3 *)jarg1;
6458   {
6459     try {
6460       result = ((Dali::Vector3 const *)arg1)->operator -();
6461     } catch (std::out_of_range& e) {
6462       {
6463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (std::exception& e) {
6466       {
6467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6468       };
6469     } catch (Dali::DaliException e) {
6470       {
6471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6472       };
6473     } catch (...) {
6474       {
6475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6476       };
6477     }
6478   }
6479
6480   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6481   return jresult;
6482 }
6483
6484
6485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6486   unsigned int jresult ;
6487   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6488   Dali::Vector3 *arg2 = 0 ;
6489   bool result;
6490
6491   arg1 = (Dali::Vector3 *)jarg1;
6492   arg2 = (Dali::Vector3 *)jarg2;
6493   if (!arg2) {
6494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6495     return 0;
6496   }
6497   {
6498     try {
6499       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6500     } catch (std::out_of_range& e) {
6501       {
6502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6503       };
6504     } catch (std::exception& e) {
6505       {
6506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6507       };
6508     } catch (Dali::DaliException e) {
6509       {
6510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6511       };
6512     } catch (...) {
6513       {
6514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6515       };
6516     }
6517   }
6518
6519   jresult = result;
6520   return jresult;
6521 }
6522
6523
6524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6525   unsigned int jresult ;
6526   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6527   Dali::Vector3 *arg2 = 0 ;
6528   bool result;
6529
6530   arg1 = (Dali::Vector3 *)jarg1;
6531   arg2 = (Dali::Vector3 *)jarg2;
6532   if (!arg2) {
6533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6534     return 0;
6535   }
6536   {
6537     try {
6538       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6539     } catch (std::out_of_range& e) {
6540       {
6541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (std::exception& e) {
6544       {
6545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6546       };
6547     } catch (Dali::DaliException e) {
6548       {
6549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6550       };
6551     } catch (...) {
6552       {
6553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6554       };
6555     }
6556   }
6557
6558   jresult = result;
6559   return jresult;
6560 }
6561
6562
6563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6564   float jresult ;
6565   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6566   unsigned int arg2 ;
6567   float *result = 0 ;
6568
6569   arg1 = (Dali::Vector3 *)jarg1;
6570   arg2 = (unsigned int)jarg2;
6571   {
6572     try {
6573       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6574     } catch (std::out_of_range& e) {
6575       {
6576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6577       };
6578     } catch (std::exception& e) {
6579       {
6580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6581       };
6582     } catch (Dali::DaliException e) {
6583       {
6584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6585       };
6586     } catch (...) {
6587       {
6588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6589       };
6590     }
6591   }
6592
6593   jresult = *result;
6594   return jresult;
6595 }
6596
6597
6598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6599   float jresult ;
6600   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6601   Dali::Vector3 *arg2 = 0 ;
6602   float result;
6603
6604   arg1 = (Dali::Vector3 *)jarg1;
6605   arg2 = (Dali::Vector3 *)jarg2;
6606   if (!arg2) {
6607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6608     return 0;
6609   }
6610   {
6611     try {
6612       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6613     } catch (std::out_of_range& e) {
6614       {
6615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6616       };
6617     } catch (std::exception& e) {
6618       {
6619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6620       };
6621     } catch (Dali::DaliException e) {
6622       {
6623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6624       };
6625     } catch (...) {
6626       {
6627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6628       };
6629     }
6630   }
6631
6632   jresult = result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6638   void * jresult ;
6639   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6640   Dali::Vector3 *arg2 = 0 ;
6641   Dali::Vector3 result;
6642
6643   arg1 = (Dali::Vector3 *)jarg1;
6644   arg2 = (Dali::Vector3 *)jarg2;
6645   if (!arg2) {
6646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6647     return 0;
6648   }
6649   {
6650     try {
6651       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6652     } catch (std::out_of_range& e) {
6653       {
6654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6655       };
6656     } catch (std::exception& e) {
6657       {
6658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6659       };
6660     } catch (Dali::DaliException e) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6663       };
6664     } catch (...) {
6665       {
6666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6667       };
6668     }
6669   }
6670
6671   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6677   float jresult ;
6678   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6679   float result;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   {
6683     try {
6684       result = (float)((Dali::Vector3 const *)arg1)->Length();
6685     } catch (std::out_of_range& e) {
6686       {
6687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (std::exception& e) {
6690       {
6691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (Dali::DaliException e) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703
6704   jresult = result;
6705   return jresult;
6706 }
6707
6708
6709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6710   float jresult ;
6711   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6712   float result;
6713
6714   arg1 = (Dali::Vector3 *)jarg1;
6715   {
6716     try {
6717       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6718     } catch (std::out_of_range& e) {
6719       {
6720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6721       };
6722     } catch (std::exception& e) {
6723       {
6724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6725       };
6726     } catch (Dali::DaliException e) {
6727       {
6728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6729       };
6730     } catch (...) {
6731       {
6732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6733       };
6734     }
6735   }
6736
6737   jresult = result;
6738   return jresult;
6739 }
6740
6741
6742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6743   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6744
6745   arg1 = (Dali::Vector3 *)jarg1;
6746   {
6747     try {
6748       (arg1)->Normalize();
6749     } catch (std::out_of_range& e) {
6750       {
6751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6752       };
6753     } catch (std::exception& e) {
6754       {
6755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6756       };
6757     } catch (Dali::DaliException e) {
6758       {
6759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6760       };
6761     } catch (...) {
6762       {
6763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6764       };
6765     }
6766   }
6767
6768 }
6769
6770
6771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6772   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6773   Dali::Vector3 *arg2 = 0 ;
6774   Dali::Vector3 *arg3 = 0 ;
6775
6776   arg1 = (Dali::Vector3 *)jarg1;
6777   arg2 = (Dali::Vector3 *)jarg2;
6778   if (!arg2) {
6779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6780     return ;
6781   }
6782   arg3 = (Dali::Vector3 *)jarg3;
6783   if (!arg3) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6785     return ;
6786   }
6787   {
6788     try {
6789       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6790     } catch (std::out_of_range& e) {
6791       {
6792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6793       };
6794     } catch (std::exception& e) {
6795       {
6796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6797       };
6798     } catch (Dali::DaliException e) {
6799       {
6800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6801       };
6802     } catch (...) {
6803       {
6804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6805       };
6806     }
6807   }
6808
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6813   void * jresult ;
6814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6815   float *result = 0 ;
6816
6817   arg1 = (Dali::Vector3 *)jarg1;
6818   {
6819     try {
6820       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6821     } catch (std::out_of_range& e) {
6822       {
6823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (std::exception& e) {
6826       {
6827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6828       };
6829     } catch (Dali::DaliException e) {
6830       {
6831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6832       };
6833     } catch (...) {
6834       {
6835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6836       };
6837     }
6838   }
6839
6840   jresult = (void *)result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6846   void * jresult ;
6847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6848   Dali::Vector2 *result = 0 ;
6849
6850   arg1 = (Dali::Vector3 *)jarg1;
6851   {
6852     try {
6853       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6854     } catch (std::out_of_range& e) {
6855       {
6856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (std::exception& e) {
6859       {
6860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6861       };
6862     } catch (Dali::DaliException e) {
6863       {
6864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6865       };
6866     } catch (...) {
6867       {
6868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6869       };
6870     }
6871   }
6872
6873   jresult = (void *)result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6879   void * jresult ;
6880   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6881   Dali::Vector2 *result = 0 ;
6882
6883   arg1 = (Dali::Vector3 *)jarg1;
6884   {
6885     try {
6886       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6887     } catch (std::out_of_range& e) {
6888       {
6889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6890       };
6891     } catch (std::exception& e) {
6892       {
6893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6894       };
6895     } catch (Dali::DaliException e) {
6896       {
6897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6898       };
6899     } catch (...) {
6900       {
6901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6902       };
6903     }
6904   }
6905
6906   jresult = (void *)result;
6907   return jresult;
6908 }
6909
6910
6911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6913   float arg2 ;
6914
6915   arg1 = (Dali::Vector3 *)jarg1;
6916   arg2 = (float)jarg2;
6917   if (arg1) (arg1)->x = arg2;
6918 }
6919
6920
6921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6922   float jresult ;
6923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6924   float result;
6925
6926   arg1 = (Dali::Vector3 *)jarg1;
6927   result = (float) ((arg1)->x);
6928   jresult = result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6934   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6935   float arg2 ;
6936
6937   arg1 = (Dali::Vector3 *)jarg1;
6938   arg2 = (float)jarg2;
6939   if (arg1) (arg1)->width = arg2;
6940 }
6941
6942
6943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6944   float jresult ;
6945   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6946   float result;
6947
6948   arg1 = (Dali::Vector3 *)jarg1;
6949   result = (float) ((arg1)->width);
6950   jresult = result;
6951   return jresult;
6952 }
6953
6954
6955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6956   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6957   float arg2 ;
6958
6959   arg1 = (Dali::Vector3 *)jarg1;
6960   arg2 = (float)jarg2;
6961   if (arg1) (arg1)->r = arg2;
6962 }
6963
6964
6965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6966   float jresult ;
6967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6968   float result;
6969
6970   arg1 = (Dali::Vector3 *)jarg1;
6971   result = (float) ((arg1)->r);
6972   jresult = result;
6973   return jresult;
6974 }
6975
6976
6977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6978   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6979   float arg2 ;
6980
6981   arg1 = (Dali::Vector3 *)jarg1;
6982   arg2 = (float)jarg2;
6983   if (arg1) (arg1)->y = arg2;
6984 }
6985
6986
6987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6988   float jresult ;
6989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6990   float result;
6991
6992   arg1 = (Dali::Vector3 *)jarg1;
6993   result = (float) ((arg1)->y);
6994   jresult = result;
6995   return jresult;
6996 }
6997
6998
6999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
7000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7001   float arg2 ;
7002
7003   arg1 = (Dali::Vector3 *)jarg1;
7004   arg2 = (float)jarg2;
7005   if (arg1) (arg1)->height = arg2;
7006 }
7007
7008
7009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7010   float jresult ;
7011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7012   float result;
7013
7014   arg1 = (Dali::Vector3 *)jarg1;
7015   result = (float) ((arg1)->height);
7016   jresult = result;
7017   return jresult;
7018 }
7019
7020
7021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7022   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7023   float arg2 ;
7024
7025   arg1 = (Dali::Vector3 *)jarg1;
7026   arg2 = (float)jarg2;
7027   if (arg1) (arg1)->g = arg2;
7028 }
7029
7030
7031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7032   float jresult ;
7033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7034   float result;
7035
7036   arg1 = (Dali::Vector3 *)jarg1;
7037   result = (float) ((arg1)->g);
7038   jresult = result;
7039   return jresult;
7040 }
7041
7042
7043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7044   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7045   float arg2 ;
7046
7047   arg1 = (Dali::Vector3 *)jarg1;
7048   arg2 = (float)jarg2;
7049   if (arg1) (arg1)->z = arg2;
7050 }
7051
7052
7053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7054   float jresult ;
7055   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7056   float result;
7057
7058   arg1 = (Dali::Vector3 *)jarg1;
7059   result = (float) ((arg1)->z);
7060   jresult = result;
7061   return jresult;
7062 }
7063
7064
7065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7066   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7067   float arg2 ;
7068
7069   arg1 = (Dali::Vector3 *)jarg1;
7070   arg2 = (float)jarg2;
7071   if (arg1) (arg1)->depth = arg2;
7072 }
7073
7074
7075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7076   float jresult ;
7077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7078   float result;
7079
7080   arg1 = (Dali::Vector3 *)jarg1;
7081   result = (float) ((arg1)->depth);
7082   jresult = result;
7083   return jresult;
7084 }
7085
7086
7087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7088   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7089   float arg2 ;
7090
7091   arg1 = (Dali::Vector3 *)jarg1;
7092   arg2 = (float)jarg2;
7093   if (arg1) (arg1)->b = arg2;
7094 }
7095
7096
7097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7098   float jresult ;
7099   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7100   float result;
7101
7102   arg1 = (Dali::Vector3 *)jarg1;
7103   result = (float) ((arg1)->b);
7104   jresult = result;
7105   return jresult;
7106 }
7107
7108
7109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7110   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7111
7112   arg1 = (Dali::Vector3 *)jarg1;
7113   {
7114     try {
7115       delete arg1;
7116     } catch (std::out_of_range& e) {
7117       {
7118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7119       };
7120     } catch (std::exception& e) {
7121       {
7122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7123       };
7124     } catch (Dali::DaliException e) {
7125       {
7126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7127       };
7128     } catch (...) {
7129       {
7130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7131       };
7132     }
7133   }
7134
7135 }
7136
7137
7138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7139   void * jresult ;
7140   Dali::Vector3 *arg1 = 0 ;
7141   Dali::Vector3 *arg2 = 0 ;
7142   Dali::Vector3 result;
7143
7144   arg1 = (Dali::Vector3 *)jarg1;
7145   if (!arg1) {
7146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7147     return 0;
7148   }
7149   arg2 = (Dali::Vector3 *)jarg2;
7150   if (!arg2) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7152     return 0;
7153   }
7154   {
7155     try {
7156       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7157     } catch (std::out_of_range& e) {
7158       {
7159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (std::exception& e) {
7162       {
7163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7164       };
7165     } catch (Dali::DaliException e) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7168       };
7169     } catch (...) {
7170       {
7171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7172       };
7173     }
7174   }
7175
7176   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7177   return jresult;
7178 }
7179
7180
7181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7182   void * jresult ;
7183   Dali::Vector3 *arg1 = 0 ;
7184   Dali::Vector3 *arg2 = 0 ;
7185   Dali::Vector3 result;
7186
7187   arg1 = (Dali::Vector3 *)jarg1;
7188   if (!arg1) {
7189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7190     return 0;
7191   }
7192   arg2 = (Dali::Vector3 *)jarg2;
7193   if (!arg2) {
7194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7195     return 0;
7196   }
7197   {
7198     try {
7199       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7200     } catch (std::out_of_range& e) {
7201       {
7202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (std::exception& e) {
7205       {
7206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (Dali::DaliException e) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7211       };
7212     } catch (...) {
7213       {
7214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7215       };
7216     }
7217   }
7218
7219   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7220   return jresult;
7221 }
7222
7223
7224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7225   void * jresult ;
7226   Dali::Vector3 *arg1 = 0 ;
7227   float *arg2 = 0 ;
7228   float *arg3 = 0 ;
7229   float temp2 ;
7230   float temp3 ;
7231   Dali::Vector3 result;
7232
7233   arg1 = (Dali::Vector3 *)jarg1;
7234   if (!arg1) {
7235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7236     return 0;
7237   }
7238   temp2 = (float)jarg2;
7239   arg2 = &temp2;
7240   temp3 = (float)jarg3;
7241   arg3 = &temp3;
7242   {
7243     try {
7244       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7245     } catch (std::out_of_range& e) {
7246       {
7247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7248       };
7249     } catch (std::exception& e) {
7250       {
7251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7252       };
7253     } catch (Dali::DaliException e) {
7254       {
7255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7256       };
7257     } catch (...) {
7258       {
7259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7260       };
7261     }
7262   }
7263
7264   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7265   return jresult;
7266 }
7267
7268
7269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7270   void * jresult ;
7271   Dali::Vector4 *result = 0 ;
7272
7273   {
7274     try {
7275       result = (Dali::Vector4 *)new Dali::Vector4();
7276     } catch (std::out_of_range& e) {
7277       {
7278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7279       };
7280     } catch (std::exception& e) {
7281       {
7282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7283       };
7284     } catch (Dali::DaliException e) {
7285       {
7286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7287       };
7288     } catch (...) {
7289       {
7290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7291       };
7292     }
7293   }
7294
7295   jresult = (void *)result;
7296   return jresult;
7297 }
7298
7299
7300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7301   void * jresult ;
7302   float arg1 ;
7303   float arg2 ;
7304   float arg3 ;
7305   float arg4 ;
7306   Dali::Vector4 *result = 0 ;
7307
7308   arg1 = (float)jarg1;
7309   arg2 = (float)jarg2;
7310   arg3 = (float)jarg3;
7311   arg4 = (float)jarg4;
7312   {
7313     try {
7314       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7315     } catch (std::out_of_range& e) {
7316       {
7317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (std::exception& e) {
7320       {
7321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7322       };
7323     } catch (Dali::DaliException e) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7326       };
7327     } catch (...) {
7328       {
7329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7330       };
7331     }
7332   }
7333
7334   jresult = (void *)result;
7335   return jresult;
7336 }
7337
7338
7339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7340   void * jresult ;
7341   float *arg1 = (float *) 0 ;
7342   Dali::Vector4 *result = 0 ;
7343
7344   arg1 = jarg1;
7345   {
7346     try {
7347       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7348     } catch (std::out_of_range& e) {
7349       {
7350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (std::exception& e) {
7353       {
7354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7355       };
7356     } catch (Dali::DaliException e) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7359       };
7360     } catch (...) {
7361       {
7362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7363       };
7364     }
7365   }
7366
7367   jresult = (void *)result;
7368
7369
7370   return jresult;
7371 }
7372
7373
7374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7375   void * jresult ;
7376   Dali::Vector2 *arg1 = 0 ;
7377   Dali::Vector4 *result = 0 ;
7378
7379   arg1 = (Dali::Vector2 *)jarg1;
7380   if (!arg1) {
7381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7382     return 0;
7383   }
7384   {
7385     try {
7386       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7387     } catch (std::out_of_range& e) {
7388       {
7389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7390       };
7391     } catch (std::exception& e) {
7392       {
7393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (Dali::DaliException e) {
7396       {
7397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7398       };
7399     } catch (...) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7402       };
7403     }
7404   }
7405
7406   jresult = (void *)result;
7407   return jresult;
7408 }
7409
7410
7411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7412   void * jresult ;
7413   Dali::Vector3 *arg1 = 0 ;
7414   Dali::Vector4 *result = 0 ;
7415
7416   arg1 = (Dali::Vector3 *)jarg1;
7417   if (!arg1) {
7418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7419     return 0;
7420   }
7421   {
7422     try {
7423       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7424     } catch (std::out_of_range& e) {
7425       {
7426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7427       };
7428     } catch (std::exception& e) {
7429       {
7430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7431       };
7432     } catch (Dali::DaliException e) {
7433       {
7434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7435       };
7436     } catch (...) {
7437       {
7438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7439       };
7440     }
7441   }
7442
7443   jresult = (void *)result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7449   void * jresult ;
7450   Dali::Vector4 *result = 0 ;
7451
7452   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7453   jresult = (void *)result;
7454   return jresult;
7455 }
7456
7457
7458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7459   void * jresult ;
7460   Dali::Vector4 *result = 0 ;
7461
7462   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7463   jresult = (void *)result;
7464   return jresult;
7465 }
7466
7467
7468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7469   void * jresult ;
7470   Dali::Vector4 *result = 0 ;
7471
7472   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7473   jresult = (void *)result;
7474   return jresult;
7475 }
7476
7477
7478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7479   void * jresult ;
7480   Dali::Vector4 *result = 0 ;
7481
7482   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7483   jresult = (void *)result;
7484   return jresult;
7485 }
7486
7487
7488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7489   void * jresult ;
7490   Dali::Vector4 *result = 0 ;
7491
7492   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7493   jresult = (void *)result;
7494   return jresult;
7495 }
7496
7497
7498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7499   void * jresult ;
7500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7501   float *arg2 = (float *) 0 ;
7502   Dali::Vector4 *result = 0 ;
7503
7504   arg1 = (Dali::Vector4 *)jarg1;
7505   arg2 = jarg2;
7506   {
7507     try {
7508       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7509     } catch (std::out_of_range& e) {
7510       {
7511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7512       };
7513     } catch (std::exception& e) {
7514       {
7515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7516       };
7517     } catch (Dali::DaliException e) {
7518       {
7519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7520       };
7521     } catch (...) {
7522       {
7523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7524       };
7525     }
7526   }
7527
7528   jresult = (void *)result;
7529
7530
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7536   void * jresult ;
7537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7538   Dali::Vector2 *arg2 = 0 ;
7539   Dali::Vector4 *result = 0 ;
7540
7541   arg1 = (Dali::Vector4 *)jarg1;
7542   arg2 = (Dali::Vector2 *)jarg2;
7543   if (!arg2) {
7544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7545     return 0;
7546   }
7547   {
7548     try {
7549       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7550     } catch (std::out_of_range& e) {
7551       {
7552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7553       };
7554     } catch (std::exception& e) {
7555       {
7556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7557       };
7558     } catch (Dali::DaliException e) {
7559       {
7560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7561       };
7562     } catch (...) {
7563       {
7564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7565       };
7566     }
7567   }
7568
7569   jresult = (void *)result;
7570   return jresult;
7571 }
7572
7573
7574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7575   void * jresult ;
7576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7577   Dali::Vector3 *arg2 = 0 ;
7578   Dali::Vector4 *result = 0 ;
7579
7580   arg1 = (Dali::Vector4 *)jarg1;
7581   arg2 = (Dali::Vector3 *)jarg2;
7582   if (!arg2) {
7583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7584     return 0;
7585   }
7586   {
7587     try {
7588       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7589     } catch (std::out_of_range& e) {
7590       {
7591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7592       };
7593     } catch (std::exception& e) {
7594       {
7595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7596       };
7597     } catch (Dali::DaliException e) {
7598       {
7599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7600       };
7601     } catch (...) {
7602       {
7603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7604       };
7605     }
7606   }
7607
7608   jresult = (void *)result;
7609   return jresult;
7610 }
7611
7612
7613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7614   void * jresult ;
7615   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7616   Dali::Vector4 *arg2 = 0 ;
7617   Dali::Vector4 result;
7618
7619   arg1 = (Dali::Vector4 *)jarg1;
7620   arg2 = (Dali::Vector4 *)jarg2;
7621   if (!arg2) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7623     return 0;
7624   }
7625   {
7626     try {
7627       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7628     } catch (std::out_of_range& e) {
7629       {
7630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7631       };
7632     } catch (std::exception& e) {
7633       {
7634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7635       };
7636     } catch (Dali::DaliException e) {
7637       {
7638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7639       };
7640     } catch (...) {
7641       {
7642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7643       };
7644     }
7645   }
7646
7647   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7653   void * jresult ;
7654   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7655   Dali::Vector4 *arg2 = 0 ;
7656   Dali::Vector4 *result = 0 ;
7657
7658   arg1 = (Dali::Vector4 *)jarg1;
7659   arg2 = (Dali::Vector4 *)jarg2;
7660   if (!arg2) {
7661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7662     return 0;
7663   }
7664   {
7665     try {
7666       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7667     } catch (std::out_of_range& e) {
7668       {
7669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7670       };
7671     } catch (std::exception& e) {
7672       {
7673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7674       };
7675     } catch (Dali::DaliException e) {
7676       {
7677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7678       };
7679     } catch (...) {
7680       {
7681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7682       };
7683     }
7684   }
7685
7686   jresult = (void *)result;
7687   return jresult;
7688 }
7689
7690
7691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7692   void * jresult ;
7693   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7694   Dali::Vector4 *arg2 = 0 ;
7695   Dali::Vector4 result;
7696
7697   arg1 = (Dali::Vector4 *)jarg1;
7698   arg2 = (Dali::Vector4 *)jarg2;
7699   if (!arg2) {
7700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7701     return 0;
7702   }
7703   {
7704     try {
7705       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7706     } catch (std::out_of_range& e) {
7707       {
7708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7709       };
7710     } catch (std::exception& e) {
7711       {
7712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7713       };
7714     } catch (Dali::DaliException e) {
7715       {
7716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7717       };
7718     } catch (...) {
7719       {
7720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7721       };
7722     }
7723   }
7724
7725   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7726   return jresult;
7727 }
7728
7729
7730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7731   void * jresult ;
7732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7733   Dali::Vector4 *arg2 = 0 ;
7734   Dali::Vector4 *result = 0 ;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   arg2 = (Dali::Vector4 *)jarg2;
7738   if (!arg2) {
7739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7740     return 0;
7741   }
7742   {
7743     try {
7744       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7745     } catch (std::out_of_range& e) {
7746       {
7747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7748       };
7749     } catch (std::exception& e) {
7750       {
7751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7752       };
7753     } catch (Dali::DaliException e) {
7754       {
7755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7756       };
7757     } catch (...) {
7758       {
7759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7760       };
7761     }
7762   }
7763
7764   jresult = (void *)result;
7765   return jresult;
7766 }
7767
7768
7769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7770   void * jresult ;
7771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7772   Dali::Vector4 *arg2 = 0 ;
7773   Dali::Vector4 result;
7774
7775   arg1 = (Dali::Vector4 *)jarg1;
7776   arg2 = (Dali::Vector4 *)jarg2;
7777   if (!arg2) {
7778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7779     return 0;
7780   }
7781   {
7782     try {
7783       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7784     } catch (std::out_of_range& e) {
7785       {
7786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7787       };
7788     } catch (std::exception& e) {
7789       {
7790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7791       };
7792     } catch (Dali::DaliException e) {
7793       {
7794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7795       };
7796     } catch (...) {
7797       {
7798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7799       };
7800     }
7801   }
7802
7803   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7804   return jresult;
7805 }
7806
7807
7808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7809   void * jresult ;
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float arg2 ;
7812   Dali::Vector4 result;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   arg2 = (float)jarg2;
7816   {
7817     try {
7818       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7819     } catch (std::out_of_range& e) {
7820       {
7821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7822       };
7823     } catch (std::exception& e) {
7824       {
7825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7826       };
7827     } catch (Dali::DaliException e) {
7828       {
7829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7830       };
7831     } catch (...) {
7832       {
7833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7834       };
7835     }
7836   }
7837
7838   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7839   return jresult;
7840 }
7841
7842
7843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7844   void * jresult ;
7845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7846   Dali::Vector4 *arg2 = 0 ;
7847   Dali::Vector4 *result = 0 ;
7848
7849   arg1 = (Dali::Vector4 *)jarg1;
7850   arg2 = (Dali::Vector4 *)jarg2;
7851   if (!arg2) {
7852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7853     return 0;
7854   }
7855   {
7856     try {
7857       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7858     } catch (std::out_of_range& e) {
7859       {
7860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7861       };
7862     } catch (std::exception& e) {
7863       {
7864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7865       };
7866     } catch (Dali::DaliException e) {
7867       {
7868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7869       };
7870     } catch (...) {
7871       {
7872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7873       };
7874     }
7875   }
7876
7877   jresult = (void *)result;
7878   return jresult;
7879 }
7880
7881
7882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7883   void * jresult ;
7884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7885   float arg2 ;
7886   Dali::Vector4 *result = 0 ;
7887
7888   arg1 = (Dali::Vector4 *)jarg1;
7889   arg2 = (float)jarg2;
7890   {
7891     try {
7892       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7893     } catch (std::out_of_range& e) {
7894       {
7895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7896       };
7897     } catch (std::exception& e) {
7898       {
7899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7900       };
7901     } catch (Dali::DaliException e) {
7902       {
7903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7904       };
7905     } catch (...) {
7906       {
7907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7908       };
7909     }
7910   }
7911
7912   jresult = (void *)result;
7913   return jresult;
7914 }
7915
7916
7917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7918   void * jresult ;
7919   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7920   Dali::Vector4 *arg2 = 0 ;
7921   Dali::Vector4 result;
7922
7923   arg1 = (Dali::Vector4 *)jarg1;
7924   arg2 = (Dali::Vector4 *)jarg2;
7925   if (!arg2) {
7926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7927     return 0;
7928   }
7929   {
7930     try {
7931       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7932     } catch (std::out_of_range& e) {
7933       {
7934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7935       };
7936     } catch (std::exception& e) {
7937       {
7938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7939       };
7940     } catch (Dali::DaliException e) {
7941       {
7942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7943       };
7944     } catch (...) {
7945       {
7946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7947       };
7948     }
7949   }
7950
7951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7952   return jresult;
7953 }
7954
7955
7956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7957   void * jresult ;
7958   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7959   float arg2 ;
7960   Dali::Vector4 result;
7961
7962   arg1 = (Dali::Vector4 *)jarg1;
7963   arg2 = (float)jarg2;
7964   {
7965     try {
7966       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7967     } catch (std::out_of_range& e) {
7968       {
7969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (std::exception& e) {
7972       {
7973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7974       };
7975     } catch (Dali::DaliException e) {
7976       {
7977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7978       };
7979     } catch (...) {
7980       {
7981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7982       };
7983     }
7984   }
7985
7986   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7987   return jresult;
7988 }
7989
7990
7991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7992   void * jresult ;
7993   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7994   Dali::Vector4 *arg2 = 0 ;
7995   Dali::Vector4 *result = 0 ;
7996
7997   arg1 = (Dali::Vector4 *)jarg1;
7998   arg2 = (Dali::Vector4 *)jarg2;
7999   if (!arg2) {
8000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8001     return 0;
8002   }
8003   {
8004     try {
8005       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8006     } catch (std::out_of_range& e) {
8007       {
8008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8009       };
8010     } catch (std::exception& e) {
8011       {
8012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8013       };
8014     } catch (Dali::DaliException e) {
8015       {
8016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8017       };
8018     } catch (...) {
8019       {
8020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8021       };
8022     }
8023   }
8024
8025   jresult = (void *)result;
8026   return jresult;
8027 }
8028
8029
8030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8031   void * jresult ;
8032   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8033   float arg2 ;
8034   Dali::Vector4 *result = 0 ;
8035
8036   arg1 = (Dali::Vector4 *)jarg1;
8037   arg2 = (float)jarg2;
8038   {
8039     try {
8040       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (Dali::DaliException e) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8052       };
8053     } catch (...) {
8054       {
8055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8056       };
8057     }
8058   }
8059
8060   jresult = (void *)result;
8061   return jresult;
8062 }
8063
8064
8065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8066   void * jresult ;
8067   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8068   Dali::Vector4 result;
8069
8070   arg1 = (Dali::Vector4 *)jarg1;
8071   {
8072     try {
8073       result = ((Dali::Vector4 const *)arg1)->operator -();
8074     } catch (std::out_of_range& e) {
8075       {
8076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (std::exception& e) {
8079       {
8080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8081       };
8082     } catch (Dali::DaliException e) {
8083       {
8084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8085       };
8086     } catch (...) {
8087       {
8088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8089       };
8090     }
8091   }
8092
8093   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8094   return jresult;
8095 }
8096
8097
8098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8099   unsigned int jresult ;
8100   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8101   Dali::Vector4 *arg2 = 0 ;
8102   bool result;
8103
8104   arg1 = (Dali::Vector4 *)jarg1;
8105   arg2 = (Dali::Vector4 *)jarg2;
8106   if (!arg2) {
8107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8108     return 0;
8109   }
8110   {
8111     try {
8112       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8113     } catch (std::out_of_range& e) {
8114       {
8115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8116       };
8117     } catch (std::exception& e) {
8118       {
8119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8120       };
8121     } catch (Dali::DaliException e) {
8122       {
8123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8124       };
8125     } catch (...) {
8126       {
8127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8128       };
8129     }
8130   }
8131
8132   jresult = result;
8133   return jresult;
8134 }
8135
8136
8137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8138   unsigned int jresult ;
8139   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8140   Dali::Vector4 *arg2 = 0 ;
8141   bool result;
8142
8143   arg1 = (Dali::Vector4 *)jarg1;
8144   arg2 = (Dali::Vector4 *)jarg2;
8145   if (!arg2) {
8146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8147     return 0;
8148   }
8149   {
8150     try {
8151       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8159       };
8160     } catch (Dali::DaliException e) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8163       };
8164     } catch (...) {
8165       {
8166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8167       };
8168     }
8169   }
8170
8171   jresult = result;
8172   return jresult;
8173 }
8174
8175
8176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8177   float jresult ;
8178   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8179   unsigned int arg2 ;
8180   float *result = 0 ;
8181
8182   arg1 = (Dali::Vector4 *)jarg1;
8183   arg2 = (unsigned int)jarg2;
8184   {
8185     try {
8186       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8187     } catch (std::out_of_range& e) {
8188       {
8189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (std::exception& e) {
8192       {
8193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8194       };
8195     } catch (Dali::DaliException e) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8198       };
8199     } catch (...) {
8200       {
8201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8202       };
8203     }
8204   }
8205
8206   jresult = *result;
8207   return jresult;
8208 }
8209
8210
8211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8212   float jresult ;
8213   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8214   Dali::Vector3 *arg2 = 0 ;
8215   float result;
8216
8217   arg1 = (Dali::Vector4 *)jarg1;
8218   arg2 = (Dali::Vector3 *)jarg2;
8219   if (!arg2) {
8220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8221     return 0;
8222   }
8223   {
8224     try {
8225       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8226     } catch (std::out_of_range& e) {
8227       {
8228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8229       };
8230     } catch (std::exception& e) {
8231       {
8232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8233       };
8234     } catch (Dali::DaliException e) {
8235       {
8236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8237       };
8238     } catch (...) {
8239       {
8240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8241       };
8242     }
8243   }
8244
8245   jresult = result;
8246   return jresult;
8247 }
8248
8249
8250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8251   float jresult ;
8252   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8253   Dali::Vector4 *arg2 = 0 ;
8254   float result;
8255
8256   arg1 = (Dali::Vector4 *)jarg1;
8257   arg2 = (Dali::Vector4 *)jarg2;
8258   if (!arg2) {
8259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8260     return 0;
8261   }
8262   {
8263     try {
8264       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8265     } catch (std::out_of_range& e) {
8266       {
8267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8268       };
8269     } catch (std::exception& e) {
8270       {
8271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8272       };
8273     } catch (Dali::DaliException e) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8276       };
8277     } catch (...) {
8278       {
8279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8280       };
8281     }
8282   }
8283
8284   jresult = result;
8285   return jresult;
8286 }
8287
8288
8289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8290   float jresult ;
8291   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8292   Dali::Vector4 *arg2 = 0 ;
8293   float result;
8294
8295   arg1 = (Dali::Vector4 *)jarg1;
8296   arg2 = (Dali::Vector4 *)jarg2;
8297   if (!arg2) {
8298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8299     return 0;
8300   }
8301   {
8302     try {
8303       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8304     } catch (std::out_of_range& e) {
8305       {
8306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8307       };
8308     } catch (std::exception& e) {
8309       {
8310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8311       };
8312     } catch (Dali::DaliException e) {
8313       {
8314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8315       };
8316     } catch (...) {
8317       {
8318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8319       };
8320     }
8321   }
8322
8323   jresult = result;
8324   return jresult;
8325 }
8326
8327
8328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8329   void * jresult ;
8330   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8331   Dali::Vector4 *arg2 = 0 ;
8332   Dali::Vector4 result;
8333
8334   arg1 = (Dali::Vector4 *)jarg1;
8335   arg2 = (Dali::Vector4 *)jarg2;
8336   if (!arg2) {
8337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8338     return 0;
8339   }
8340   {
8341     try {
8342       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8343     } catch (std::out_of_range& e) {
8344       {
8345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8346       };
8347     } catch (std::exception& e) {
8348       {
8349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8350       };
8351     } catch (Dali::DaliException e) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8354       };
8355     } catch (...) {
8356       {
8357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8358       };
8359     }
8360   }
8361
8362   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8368   float jresult ;
8369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8370   float result;
8371
8372   arg1 = (Dali::Vector4 *)jarg1;
8373   {
8374     try {
8375       result = (float)((Dali::Vector4 const *)arg1)->Length();
8376     } catch (std::out_of_range& e) {
8377       {
8378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (std::exception& e) {
8381       {
8382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8383       };
8384     } catch (Dali::DaliException e) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8387       };
8388     } catch (...) {
8389       {
8390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8391       };
8392     }
8393   }
8394
8395   jresult = result;
8396   return jresult;
8397 }
8398
8399
8400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8401   float jresult ;
8402   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8403   float result;
8404
8405   arg1 = (Dali::Vector4 *)jarg1;
8406   {
8407     try {
8408       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8409     } catch (std::out_of_range& e) {
8410       {
8411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8412       };
8413     } catch (std::exception& e) {
8414       {
8415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8416       };
8417     } catch (Dali::DaliException e) {
8418       {
8419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8420       };
8421     } catch (...) {
8422       {
8423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8424       };
8425     }
8426   }
8427
8428   jresult = result;
8429   return jresult;
8430 }
8431
8432
8433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8435
8436   arg1 = (Dali::Vector4 *)jarg1;
8437   {
8438     try {
8439       (arg1)->Normalize();
8440     } catch (std::out_of_range& e) {
8441       {
8442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8443       };
8444     } catch (std::exception& e) {
8445       {
8446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8447       };
8448     } catch (Dali::DaliException e) {
8449       {
8450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8451       };
8452     } catch (...) {
8453       {
8454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8455       };
8456     }
8457   }
8458
8459 }
8460
8461
8462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8463   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8464   Dali::Vector4 *arg2 = 0 ;
8465   Dali::Vector4 *arg3 = 0 ;
8466
8467   arg1 = (Dali::Vector4 *)jarg1;
8468   arg2 = (Dali::Vector4 *)jarg2;
8469   if (!arg2) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8471     return ;
8472   }
8473   arg3 = (Dali::Vector4 *)jarg3;
8474   if (!arg3) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8476     return ;
8477   }
8478   {
8479     try {
8480       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8488       };
8489     } catch (Dali::DaliException e) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8492       };
8493     } catch (...) {
8494       {
8495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8496       };
8497     }
8498   }
8499
8500 }
8501
8502
8503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8504   void * jresult ;
8505   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8506   float *result = 0 ;
8507
8508   arg1 = (Dali::Vector4 *)jarg1;
8509   {
8510     try {
8511       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8512     } catch (std::out_of_range& e) {
8513       {
8514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8515       };
8516     } catch (std::exception& e) {
8517       {
8518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8519       };
8520     } catch (Dali::DaliException e) {
8521       {
8522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8523       };
8524     } catch (...) {
8525       {
8526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8527       };
8528     }
8529   }
8530
8531   jresult = (void *)result;
8532   return jresult;
8533 }
8534
8535
8536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8538   float arg2 ;
8539
8540   arg1 = (Dali::Vector4 *)jarg1;
8541   arg2 = (float)jarg2;
8542   if (arg1) (arg1)->x = arg2;
8543 }
8544
8545
8546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8547   float jresult ;
8548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8549   float result;
8550
8551   arg1 = (Dali::Vector4 *)jarg1;
8552   result = (float) ((arg1)->x);
8553   jresult = result;
8554   return jresult;
8555 }
8556
8557
8558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8559   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8560   float arg2 ;
8561
8562   arg1 = (Dali::Vector4 *)jarg1;
8563   arg2 = (float)jarg2;
8564   if (arg1) (arg1)->r = arg2;
8565 }
8566
8567
8568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8569   float jresult ;
8570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8571   float result;
8572
8573   arg1 = (Dali::Vector4 *)jarg1;
8574   result = (float) ((arg1)->r);
8575   jresult = result;
8576   return jresult;
8577 }
8578
8579
8580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8582   float arg2 ;
8583
8584   arg1 = (Dali::Vector4 *)jarg1;
8585   arg2 = (float)jarg2;
8586   if (arg1) (arg1)->s = arg2;
8587 }
8588
8589
8590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8591   float jresult ;
8592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8593   float result;
8594
8595   arg1 = (Dali::Vector4 *)jarg1;
8596   result = (float) ((arg1)->s);
8597   jresult = result;
8598   return jresult;
8599 }
8600
8601
8602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8604   float arg2 ;
8605
8606   arg1 = (Dali::Vector4 *)jarg1;
8607   arg2 = (float)jarg2;
8608   if (arg1) (arg1)->y = arg2;
8609 }
8610
8611
8612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8613   float jresult ;
8614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8615   float result;
8616
8617   arg1 = (Dali::Vector4 *)jarg1;
8618   result = (float) ((arg1)->y);
8619   jresult = result;
8620   return jresult;
8621 }
8622
8623
8624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8625   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8626   float arg2 ;
8627
8628   arg1 = (Dali::Vector4 *)jarg1;
8629   arg2 = (float)jarg2;
8630   if (arg1) (arg1)->g = arg2;
8631 }
8632
8633
8634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8635   float jresult ;
8636   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8637   float result;
8638
8639   arg1 = (Dali::Vector4 *)jarg1;
8640   result = (float) ((arg1)->g);
8641   jresult = result;
8642   return jresult;
8643 }
8644
8645
8646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8647   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8648   float arg2 ;
8649
8650   arg1 = (Dali::Vector4 *)jarg1;
8651   arg2 = (float)jarg2;
8652   if (arg1) (arg1)->t = arg2;
8653 }
8654
8655
8656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8657   float jresult ;
8658   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8659   float result;
8660
8661   arg1 = (Dali::Vector4 *)jarg1;
8662   result = (float) ((arg1)->t);
8663   jresult = result;
8664   return jresult;
8665 }
8666
8667
8668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8669   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8670   float arg2 ;
8671
8672   arg1 = (Dali::Vector4 *)jarg1;
8673   arg2 = (float)jarg2;
8674   if (arg1) (arg1)->z = arg2;
8675 }
8676
8677
8678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8679   float jresult ;
8680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8681   float result;
8682
8683   arg1 = (Dali::Vector4 *)jarg1;
8684   result = (float) ((arg1)->z);
8685   jresult = result;
8686   return jresult;
8687 }
8688
8689
8690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8692   float arg2 ;
8693
8694   arg1 = (Dali::Vector4 *)jarg1;
8695   arg2 = (float)jarg2;
8696   if (arg1) (arg1)->b = arg2;
8697 }
8698
8699
8700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8701   float jresult ;
8702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8703   float result;
8704
8705   arg1 = (Dali::Vector4 *)jarg1;
8706   result = (float) ((arg1)->b);
8707   jresult = result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8714   float arg2 ;
8715
8716   arg1 = (Dali::Vector4 *)jarg1;
8717   arg2 = (float)jarg2;
8718   if (arg1) (arg1)->p = arg2;
8719 }
8720
8721
8722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8723   float jresult ;
8724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8725   float result;
8726
8727   arg1 = (Dali::Vector4 *)jarg1;
8728   result = (float) ((arg1)->p);
8729   jresult = result;
8730   return jresult;
8731 }
8732
8733
8734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8736   float arg2 ;
8737
8738   arg1 = (Dali::Vector4 *)jarg1;
8739   arg2 = (float)jarg2;
8740   if (arg1) (arg1)->w = arg2;
8741 }
8742
8743
8744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8745   float jresult ;
8746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8747   float result;
8748
8749   arg1 = (Dali::Vector4 *)jarg1;
8750   result = (float) ((arg1)->w);
8751   jresult = result;
8752   return jresult;
8753 }
8754
8755
8756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8758   float arg2 ;
8759
8760   arg1 = (Dali::Vector4 *)jarg1;
8761   arg2 = (float)jarg2;
8762   if (arg1) (arg1)->a = arg2;
8763 }
8764
8765
8766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8767   float jresult ;
8768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8769   float result;
8770
8771   arg1 = (Dali::Vector4 *)jarg1;
8772   result = (float) ((arg1)->a);
8773   jresult = result;
8774   return jresult;
8775 }
8776
8777
8778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8780   float arg2 ;
8781
8782   arg1 = (Dali::Vector4 *)jarg1;
8783   arg2 = (float)jarg2;
8784   if (arg1) (arg1)->q = arg2;
8785 }
8786
8787
8788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8789   float jresult ;
8790   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8791   float result;
8792
8793   arg1 = (Dali::Vector4 *)jarg1;
8794   result = (float) ((arg1)->q);
8795   jresult = result;
8796   return jresult;
8797 }
8798
8799
8800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8802
8803   arg1 = (Dali::Vector4 *)jarg1;
8804   {
8805     try {
8806       delete arg1;
8807     } catch (std::out_of_range& e) {
8808       {
8809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8810       };
8811     } catch (std::exception& e) {
8812       {
8813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8814       };
8815     } catch (Dali::DaliException e) {
8816       {
8817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8818       };
8819     } catch (...) {
8820       {
8821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8822       };
8823     }
8824   }
8825
8826 }
8827
8828
8829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8830   void * jresult ;
8831   Dali::Vector4 *arg1 = 0 ;
8832   Dali::Vector4 *arg2 = 0 ;
8833   Dali::Vector4 result;
8834
8835   arg1 = (Dali::Vector4 *)jarg1;
8836   if (!arg1) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8838     return 0;
8839   }
8840   arg2 = (Dali::Vector4 *)jarg2;
8841   if (!arg2) {
8842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8843     return 0;
8844   }
8845   {
8846     try {
8847       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8848     } catch (std::out_of_range& e) {
8849       {
8850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (std::exception& e) {
8853       {
8854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8855       };
8856     } catch (Dali::DaliException e) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8859       };
8860     } catch (...) {
8861       {
8862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8863       };
8864     }
8865   }
8866
8867   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8868   return jresult;
8869 }
8870
8871
8872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8873   void * jresult ;
8874   Dali::Vector4 *arg1 = 0 ;
8875   Dali::Vector4 *arg2 = 0 ;
8876   Dali::Vector4 result;
8877
8878   arg1 = (Dali::Vector4 *)jarg1;
8879   if (!arg1) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8881     return 0;
8882   }
8883   arg2 = (Dali::Vector4 *)jarg2;
8884   if (!arg2) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8886     return 0;
8887   }
8888   {
8889     try {
8890       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8891     } catch (std::out_of_range& e) {
8892       {
8893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (std::exception& e) {
8896       {
8897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8898       };
8899     } catch (Dali::DaliException e) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8902       };
8903     } catch (...) {
8904       {
8905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8906       };
8907     }
8908   }
8909
8910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8911   return jresult;
8912 }
8913
8914
8915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8916   void * jresult ;
8917   Dali::Vector4 *arg1 = 0 ;
8918   float *arg2 = 0 ;
8919   float *arg3 = 0 ;
8920   float temp2 ;
8921   float temp3 ;
8922   Dali::Vector4 result;
8923
8924   arg1 = (Dali::Vector4 *)jarg1;
8925   if (!arg1) {
8926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8927     return 0;
8928   }
8929   temp2 = (float)jarg2;
8930   arg2 = &temp2;
8931   temp3 = (float)jarg3;
8932   arg3 = &temp3;
8933   {
8934     try {
8935       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8936     } catch (std::out_of_range& e) {
8937       {
8938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (std::exception& e) {
8941       {
8942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8943       };
8944     } catch (Dali::DaliException e) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8947       };
8948     } catch (...) {
8949       {
8950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8951       };
8952     }
8953   }
8954
8955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8956   return jresult;
8957 }
8958
8959
8960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8961   void * jresult ;
8962   Dali::Uint16Pair *result = 0 ;
8963
8964   {
8965     try {
8966       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8967     } catch (std::out_of_range& e) {
8968       {
8969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8970       };
8971     } catch (std::exception& e) {
8972       {
8973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8974       };
8975     } catch (Dali::DaliException e) {
8976       {
8977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8978       };
8979     } catch (...) {
8980       {
8981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8982       };
8983     }
8984   }
8985
8986   jresult = (void *)result;
8987   return jresult;
8988 }
8989
8990
8991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8992   void * jresult ;
8993   uint32_t arg1 ;
8994   uint32_t arg2 ;
8995   Dali::Uint16Pair *result = 0 ;
8996
8997   arg1 = (uint32_t)jarg1;
8998   arg2 = (uint32_t)jarg2;
8999   {
9000     try {
9001       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9002     } catch (std::out_of_range& e) {
9003       {
9004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (std::exception& e) {
9007       {
9008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9009       };
9010     } catch (Dali::DaliException e) {
9011       {
9012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9013       };
9014     } catch (...) {
9015       {
9016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9017       };
9018     }
9019   }
9020
9021   jresult = (void *)result;
9022   return jresult;
9023 }
9024
9025
9026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9027   void * jresult ;
9028   Dali::Uint16Pair *arg1 = 0 ;
9029   Dali::Uint16Pair *result = 0 ;
9030
9031   arg1 = (Dali::Uint16Pair *)jarg1;
9032   if (!arg1) {
9033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9034     return 0;
9035   }
9036   {
9037     try {
9038       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9039     } catch (std::out_of_range& e) {
9040       {
9041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9042       };
9043     } catch (std::exception& e) {
9044       {
9045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9046       };
9047     } catch (Dali::DaliException e) {
9048       {
9049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9050       };
9051     } catch (...) {
9052       {
9053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9054       };
9055     }
9056   }
9057
9058   jresult = (void *)result;
9059   return jresult;
9060 }
9061
9062
9063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9064   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9065   uint16_t arg2 ;
9066
9067   arg1 = (Dali::Uint16Pair *)jarg1;
9068   arg2 = (uint16_t)jarg2;
9069   {
9070     try {
9071       (arg1)->SetWidth(arg2);
9072     } catch (std::out_of_range& e) {
9073       {
9074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9075       };
9076     } catch (std::exception& e) {
9077       {
9078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9079       };
9080     } catch (Dali::DaliException e) {
9081       {
9082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9083       };
9084     } catch (...) {
9085       {
9086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9087       };
9088     }
9089   }
9090
9091 }
9092
9093
9094 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9095   unsigned short jresult ;
9096   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9097   uint16_t result;
9098
9099   arg1 = (Dali::Uint16Pair *)jarg1;
9100   {
9101     try {
9102       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9103     } catch (std::out_of_range& e) {
9104       {
9105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (std::exception& e) {
9108       {
9109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9110       };
9111     } catch (Dali::DaliException e) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9114       };
9115     } catch (...) {
9116       {
9117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9118       };
9119     }
9120   }
9121
9122   jresult = result;
9123   return jresult;
9124 }
9125
9126
9127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9128   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9129   uint16_t arg2 ;
9130
9131   arg1 = (Dali::Uint16Pair *)jarg1;
9132   arg2 = (uint16_t)jarg2;
9133   {
9134     try {
9135       (arg1)->SetHeight(arg2);
9136     } catch (std::out_of_range& e) {
9137       {
9138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9139       };
9140     } catch (std::exception& e) {
9141       {
9142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9143       };
9144     } catch (Dali::DaliException e) {
9145       {
9146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9151       };
9152     }
9153   }
9154
9155 }
9156
9157
9158 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9159   unsigned short jresult ;
9160   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9161   uint16_t result;
9162
9163   arg1 = (Dali::Uint16Pair *)jarg1;
9164   {
9165     try {
9166       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9167     } catch (std::out_of_range& e) {
9168       {
9169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9170       };
9171     } catch (std::exception& e) {
9172       {
9173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9174       };
9175     } catch (Dali::DaliException e) {
9176       {
9177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9178       };
9179     } catch (...) {
9180       {
9181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9182       };
9183     }
9184   }
9185
9186   jresult = result;
9187   return jresult;
9188 }
9189
9190
9191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9192   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9193   uint16_t arg2 ;
9194
9195   arg1 = (Dali::Uint16Pair *)jarg1;
9196   arg2 = (uint16_t)jarg2;
9197   {
9198     try {
9199       (arg1)->SetX(arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9207       };
9208     } catch (Dali::DaliException e) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9211       };
9212     } catch (...) {
9213       {
9214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9215       };
9216     }
9217   }
9218
9219 }
9220
9221
9222 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9223   unsigned short jresult ;
9224   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9225   uint16_t result;
9226
9227   arg1 = (Dali::Uint16Pair *)jarg1;
9228   {
9229     try {
9230       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9231     } catch (std::out_of_range& e) {
9232       {
9233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9234       };
9235     } catch (std::exception& e) {
9236       {
9237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9238       };
9239     } catch (Dali::DaliException e) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9242       };
9243     } catch (...) {
9244       {
9245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9246       };
9247     }
9248   }
9249
9250   jresult = result;
9251   return jresult;
9252 }
9253
9254
9255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9256   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9257   uint16_t arg2 ;
9258
9259   arg1 = (Dali::Uint16Pair *)jarg1;
9260   arg2 = (uint16_t)jarg2;
9261   {
9262     try {
9263       (arg1)->SetY(arg2);
9264     } catch (std::out_of_range& e) {
9265       {
9266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9267       };
9268     } catch (std::exception& e) {
9269       {
9270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9271       };
9272     } catch (Dali::DaliException e) {
9273       {
9274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9275       };
9276     } catch (...) {
9277       {
9278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9279       };
9280     }
9281   }
9282
9283 }
9284
9285
9286 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9287   unsigned short jresult ;
9288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9289   uint16_t result;
9290
9291   arg1 = (Dali::Uint16Pair *)jarg1;
9292   {
9293     try {
9294       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9295     } catch (std::out_of_range& e) {
9296       {
9297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9298       };
9299     } catch (std::exception& e) {
9300       {
9301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9302       };
9303     } catch (Dali::DaliException e) {
9304       {
9305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9306       };
9307     } catch (...) {
9308       {
9309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9310       };
9311     }
9312   }
9313
9314   jresult = result;
9315   return jresult;
9316 }
9317
9318
9319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9320   void * jresult ;
9321   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9322   Dali::Uint16Pair *arg2 = 0 ;
9323   Dali::Uint16Pair *result = 0 ;
9324
9325   arg1 = (Dali::Uint16Pair *)jarg1;
9326   arg2 = (Dali::Uint16Pair *)jarg2;
9327   if (!arg2) {
9328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9329     return 0;
9330   }
9331   {
9332     try {
9333       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9334     } catch (std::out_of_range& e) {
9335       {
9336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9337       };
9338     } catch (std::exception& e) {
9339       {
9340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9341       };
9342     } catch (Dali::DaliException e) {
9343       {
9344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9345       };
9346     } catch (...) {
9347       {
9348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9349       };
9350     }
9351   }
9352
9353   jresult = (void *)result;
9354   return jresult;
9355 }
9356
9357
9358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9359   unsigned int jresult ;
9360   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9361   Dali::Uint16Pair *arg2 = 0 ;
9362   bool result;
9363
9364   arg1 = (Dali::Uint16Pair *)jarg1;
9365   arg2 = (Dali::Uint16Pair *)jarg2;
9366   if (!arg2) {
9367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9368     return 0;
9369   }
9370   {
9371     try {
9372       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9373     } catch (std::out_of_range& e) {
9374       {
9375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9376       };
9377     } catch (std::exception& e) {
9378       {
9379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9380       };
9381     } catch (Dali::DaliException e) {
9382       {
9383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9384       };
9385     } catch (...) {
9386       {
9387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9388       };
9389     }
9390   }
9391
9392   jresult = result;
9393   return jresult;
9394 }
9395
9396
9397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9398   unsigned int jresult ;
9399   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9400   Dali::Uint16Pair *arg2 = 0 ;
9401   bool result;
9402
9403   arg1 = (Dali::Uint16Pair *)jarg1;
9404   arg2 = (Dali::Uint16Pair *)jarg2;
9405   if (!arg2) {
9406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9407     return 0;
9408   }
9409   {
9410     try {
9411       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9412     } catch (std::out_of_range& e) {
9413       {
9414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (std::exception& e) {
9417       {
9418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9419       };
9420     } catch (Dali::DaliException e) {
9421       {
9422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9423       };
9424     } catch (...) {
9425       {
9426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9427       };
9428     }
9429   }
9430
9431   jresult = result;
9432   return jresult;
9433 }
9434
9435
9436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9437   unsigned int jresult ;
9438   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9439   Dali::Uint16Pair *arg2 = 0 ;
9440   bool result;
9441
9442   arg1 = (Dali::Uint16Pair *)jarg1;
9443   arg2 = (Dali::Uint16Pair *)jarg2;
9444   if (!arg2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9446     return 0;
9447   }
9448   {
9449     try {
9450       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9451     } catch (std::out_of_range& e) {
9452       {
9453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9454       };
9455     } catch (std::exception& e) {
9456       {
9457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9458       };
9459     } catch (Dali::DaliException e) {
9460       {
9461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9462       };
9463     } catch (...) {
9464       {
9465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9466       };
9467     }
9468   }
9469
9470   jresult = result;
9471   return jresult;
9472 }
9473
9474
9475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9476   unsigned int jresult ;
9477   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9478   Dali::Uint16Pair *arg2 = 0 ;
9479   bool result;
9480
9481   arg1 = (Dali::Uint16Pair *)jarg1;
9482   arg2 = (Dali::Uint16Pair *)jarg2;
9483   if (!arg2) {
9484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9485     return 0;
9486   }
9487   {
9488     try {
9489       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9490     } catch (std::out_of_range& e) {
9491       {
9492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9493       };
9494     } catch (std::exception& e) {
9495       {
9496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (Dali::DaliException e) {
9499       {
9500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508
9509   jresult = result;
9510   return jresult;
9511 }
9512
9513
9514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9515   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9516
9517   arg1 = (Dali::Uint16Pair *)jarg1;
9518   {
9519     try {
9520       delete arg1;
9521     } catch (std::out_of_range& e) {
9522       {
9523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9524       };
9525     } catch (std::exception& e) {
9526       {
9527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9528       };
9529     } catch (Dali::DaliException e) {
9530       {
9531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9532       };
9533     } catch (...) {
9534       {
9535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9536       };
9537     }
9538   }
9539
9540 }
9541
9542
9543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9544   void * jresult ;
9545   Dali::Degree *result = 0 ;
9546
9547   {
9548     try {
9549       result = (Dali::Degree *)new Dali::Degree();
9550     } catch (std::out_of_range& e) {
9551       {
9552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (std::exception& e) {
9555       {
9556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (Dali::DaliException e) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9561       };
9562     } catch (...) {
9563       {
9564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9565       };
9566     }
9567   }
9568
9569   jresult = (void *)result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9575   void * jresult ;
9576   float arg1 ;
9577   Dali::Degree *result = 0 ;
9578
9579   arg1 = (float)jarg1;
9580   {
9581     try {
9582       result = (Dali::Degree *)new Dali::Degree(arg1);
9583     } catch (std::out_of_range& e) {
9584       {
9585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (std::exception& e) {
9588       {
9589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9590       };
9591     } catch (Dali::DaliException e) {
9592       {
9593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9594       };
9595     } catch (...) {
9596       {
9597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9598       };
9599     }
9600   }
9601
9602   jresult = (void *)result;
9603   return jresult;
9604 }
9605
9606
9607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9608   void * jresult ;
9609   Dali::Radian arg1 ;
9610   Dali::Radian *argp1 ;
9611   Dali::Degree *result = 0 ;
9612
9613   argp1 = (Dali::Radian *)jarg1;
9614   if (!argp1) {
9615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9616     return 0;
9617   }
9618   arg1 = *argp1;
9619   {
9620     try {
9621       result = (Dali::Degree *)new Dali::Degree(arg1);
9622     } catch (std::out_of_range& e) {
9623       {
9624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9625       };
9626     } catch (std::exception& e) {
9627       {
9628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9629       };
9630     } catch (Dali::DaliException e) {
9631       {
9632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9633       };
9634     } catch (...) {
9635       {
9636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9637       };
9638     }
9639   }
9640
9641   jresult = (void *)result;
9642   return jresult;
9643 }
9644
9645
9646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9647   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9648   float arg2 ;
9649
9650   arg1 = (Dali::Degree *)jarg1;
9651   arg2 = (float)jarg2;
9652   if (arg1) (arg1)->degree = arg2;
9653 }
9654
9655
9656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9657   float jresult ;
9658   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9659   float result;
9660
9661   arg1 = (Dali::Degree *)jarg1;
9662   result = (float) ((arg1)->degree);
9663   jresult = result;
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9669   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9670
9671   arg1 = (Dali::Degree *)jarg1;
9672   {
9673     try {
9674       delete arg1;
9675     } catch (std::out_of_range& e) {
9676       {
9677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9678       };
9679     } catch (std::exception& e) {
9680       {
9681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9682       };
9683     } catch (Dali::DaliException e) {
9684       {
9685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9686       };
9687     } catch (...) {
9688       {
9689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9690       };
9691     }
9692   }
9693
9694 }
9695
9696
9697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9698   void * jresult ;
9699   Dali::Radian *result = 0 ;
9700
9701   result = (Dali::Radian *)&Dali::ANGLE_360;
9702   jresult = (void *)result;
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9708   void * jresult ;
9709   Dali::Radian *result = 0 ;
9710
9711   result = (Dali::Radian *)&Dali::ANGLE_315;
9712   jresult = (void *)result;
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9718   void * jresult ;
9719   Dali::Radian *result = 0 ;
9720
9721   result = (Dali::Radian *)&Dali::ANGLE_270;
9722   jresult = (void *)result;
9723   return jresult;
9724 }
9725
9726
9727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9728   void * jresult ;
9729   Dali::Radian *result = 0 ;
9730
9731   result = (Dali::Radian *)&Dali::ANGLE_225;
9732   jresult = (void *)result;
9733   return jresult;
9734 }
9735
9736
9737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9738   void * jresult ;
9739   Dali::Radian *result = 0 ;
9740
9741   result = (Dali::Radian *)&Dali::ANGLE_180;
9742   jresult = (void *)result;
9743   return jresult;
9744 }
9745
9746
9747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9748   void * jresult ;
9749   Dali::Radian *result = 0 ;
9750
9751   result = (Dali::Radian *)&Dali::ANGLE_135;
9752   jresult = (void *)result;
9753   return jresult;
9754 }
9755
9756
9757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9758   void * jresult ;
9759   Dali::Radian *result = 0 ;
9760
9761   result = (Dali::Radian *)&Dali::ANGLE_120;
9762   jresult = (void *)result;
9763   return jresult;
9764 }
9765
9766
9767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9768   void * jresult ;
9769   Dali::Radian *result = 0 ;
9770
9771   result = (Dali::Radian *)&Dali::ANGLE_90;
9772   jresult = (void *)result;
9773   return jresult;
9774 }
9775
9776
9777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9778   void * jresult ;
9779   Dali::Radian *result = 0 ;
9780
9781   result = (Dali::Radian *)&Dali::ANGLE_60;
9782   jresult = (void *)result;
9783   return jresult;
9784 }
9785
9786
9787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9788   void * jresult ;
9789   Dali::Radian *result = 0 ;
9790
9791   result = (Dali::Radian *)&Dali::ANGLE_45;
9792   jresult = (void *)result;
9793   return jresult;
9794 }
9795
9796
9797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9798   void * jresult ;
9799   Dali::Radian *result = 0 ;
9800
9801   result = (Dali::Radian *)&Dali::ANGLE_30;
9802   jresult = (void *)result;
9803   return jresult;
9804 }
9805
9806
9807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9808   void * jresult ;
9809   Dali::Radian *result = 0 ;
9810
9811   result = (Dali::Radian *)&Dali::ANGLE_0;
9812   jresult = (void *)result;
9813   return jresult;
9814 }
9815
9816
9817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9818   unsigned int jresult ;
9819   Dali::Degree *arg1 = 0 ;
9820   Dali::Degree *arg2 = 0 ;
9821   bool result;
9822
9823   arg1 = (Dali::Degree *)jarg1;
9824   if (!arg1) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9826     return 0;
9827   }
9828   arg2 = (Dali::Degree *)jarg2;
9829   if (!arg2) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (Dali::DaliException e) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9847       };
9848     } catch (...) {
9849       {
9850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9851       };
9852     }
9853   }
9854
9855   jresult = result;
9856   return jresult;
9857 }
9858
9859
9860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9861   unsigned int jresult ;
9862   Dali::Degree *arg1 = 0 ;
9863   Dali::Degree *arg2 = 0 ;
9864   bool result;
9865
9866   arg1 = (Dali::Degree *)jarg1;
9867   if (!arg1) {
9868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9869     return 0;
9870   }
9871   arg2 = (Dali::Degree *)jarg2;
9872   if (!arg2) {
9873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9874     return 0;
9875   }
9876   {
9877     try {
9878       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9879     } catch (std::out_of_range& e) {
9880       {
9881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (std::exception& e) {
9884       {
9885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9886       };
9887     } catch (Dali::DaliException e) {
9888       {
9889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9890       };
9891     } catch (...) {
9892       {
9893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9894       };
9895     }
9896   }
9897
9898   jresult = result;
9899   return jresult;
9900 }
9901
9902
9903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9904   void * jresult ;
9905   Dali::Degree arg1 ;
9906   float arg2 ;
9907   float arg3 ;
9908   Dali::Degree *argp1 ;
9909   Dali::Degree result;
9910
9911   argp1 = (Dali::Degree *)jarg1;
9912   if (!argp1) {
9913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9914     return 0;
9915   }
9916   arg1 = *argp1;
9917   arg2 = (float)jarg2;
9918   arg3 = (float)jarg3;
9919   {
9920     try {
9921       result = Dali::Clamp(arg1,arg2,arg3);
9922     } catch (std::out_of_range& e) {
9923       {
9924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (std::exception& e) {
9927       {
9928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9929       };
9930     } catch (Dali::DaliException e) {
9931       {
9932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9933       };
9934     } catch (...) {
9935       {
9936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9937       };
9938     }
9939   }
9940
9941   jresult = new Dali::Degree((const Dali::Degree &)result);
9942   return jresult;
9943 }
9944
9945
9946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9947   void * jresult ;
9948   Dali::Radian *result = 0 ;
9949
9950   {
9951     try {
9952       result = (Dali::Radian *)new Dali::Radian();
9953     } catch (std::out_of_range& e) {
9954       {
9955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (std::exception& e) {
9958       {
9959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (Dali::DaliException e) {
9962       {
9963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971
9972   jresult = (void *)result;
9973   return jresult;
9974 }
9975
9976
9977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9978   void * jresult ;
9979   float arg1 ;
9980   Dali::Radian *result = 0 ;
9981
9982   arg1 = (float)jarg1;
9983   {
9984     try {
9985       result = (Dali::Radian *)new Dali::Radian(arg1);
9986     } catch (std::out_of_range& e) {
9987       {
9988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (std::exception& e) {
9991       {
9992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (Dali::DaliException e) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9997       };
9998     } catch (...) {
9999       {
10000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10001       };
10002     }
10003   }
10004
10005   jresult = (void *)result;
10006   return jresult;
10007 }
10008
10009
10010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10011   void * jresult ;
10012   Dali::Degree arg1 ;
10013   Dali::Degree *argp1 ;
10014   Dali::Radian *result = 0 ;
10015
10016   argp1 = (Dali::Degree *)jarg1;
10017   if (!argp1) {
10018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10019     return 0;
10020   }
10021   arg1 = *argp1;
10022   {
10023     try {
10024       result = (Dali::Radian *)new Dali::Radian(arg1);
10025     } catch (std::out_of_range& e) {
10026       {
10027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10028       };
10029     } catch (std::exception& e) {
10030       {
10031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10032       };
10033     } catch (Dali::DaliException e) {
10034       {
10035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10036       };
10037     } catch (...) {
10038       {
10039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10040       };
10041     }
10042   }
10043
10044   jresult = (void *)result;
10045   return jresult;
10046 }
10047
10048
10049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10050   void * jresult ;
10051   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10052   float arg2 ;
10053   Dali::Radian *result = 0 ;
10054
10055   arg1 = (Dali::Radian *)jarg1;
10056   arg2 = (float)jarg2;
10057   {
10058     try {
10059       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10060     } catch (std::out_of_range& e) {
10061       {
10062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10063       };
10064     } catch (std::exception& e) {
10065       {
10066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10067       };
10068     } catch (Dali::DaliException e) {
10069       {
10070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10071       };
10072     } catch (...) {
10073       {
10074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10075       };
10076     }
10077   }
10078
10079   jresult = (void *)result;
10080   return jresult;
10081 }
10082
10083
10084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10085   void * jresult ;
10086   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10087   Dali::Degree arg2 ;
10088   Dali::Degree *argp2 ;
10089   Dali::Radian *result = 0 ;
10090
10091   arg1 = (Dali::Radian *)jarg1;
10092   argp2 = (Dali::Degree *)jarg2;
10093   if (!argp2) {
10094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10095     return 0;
10096   }
10097   arg2 = *argp2;
10098   {
10099     try {
10100       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10101     } catch (std::out_of_range& e) {
10102       {
10103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10104       };
10105     } catch (std::exception& e) {
10106       {
10107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10108       };
10109     } catch (Dali::DaliException e) {
10110       {
10111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10112       };
10113     } catch (...) {
10114       {
10115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10116       };
10117     }
10118   }
10119
10120   jresult = (void *)result;
10121   return jresult;
10122 }
10123
10124
10125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10126   float jresult ;
10127   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10128   float result;
10129
10130   arg1 = (Dali::Radian *)jarg1;
10131   {
10132     try {
10133       result = (float)((Dali::Radian const *)arg1)->operator float();
10134     } catch (std::out_of_range& e) {
10135       {
10136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (std::exception& e) {
10139       {
10140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10141       };
10142     } catch (Dali::DaliException e) {
10143       {
10144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10145       };
10146     } catch (...) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10149       };
10150     }
10151   }
10152
10153   jresult = result;
10154   return jresult;
10155 }
10156
10157
10158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10159   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10160   float arg2 ;
10161
10162   arg1 = (Dali::Radian *)jarg1;
10163   arg2 = (float)jarg2;
10164   if (arg1) (arg1)->radian = arg2;
10165 }
10166
10167
10168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10169   float jresult ;
10170   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10171   float result;
10172
10173   arg1 = (Dali::Radian *)jarg1;
10174   result = (float) ((arg1)->radian);
10175   jresult = result;
10176   return jresult;
10177 }
10178
10179
10180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10181   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10182
10183   arg1 = (Dali::Radian *)jarg1;
10184   {
10185     try {
10186       delete arg1;
10187     } catch (std::out_of_range& e) {
10188       {
10189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10190       };
10191     } catch (std::exception& e) {
10192       {
10193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10194       };
10195     } catch (Dali::DaliException e) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10198       };
10199     } catch (...) {
10200       {
10201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10202       };
10203     }
10204   }
10205
10206 }
10207
10208
10209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10210   unsigned int jresult ;
10211   Dali::Radian arg1 ;
10212   Dali::Radian arg2 ;
10213   Dali::Radian *argp1 ;
10214   Dali::Radian *argp2 ;
10215   bool result;
10216
10217   argp1 = (Dali::Radian *)jarg1;
10218   if (!argp1) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg1 = *argp1;
10223   argp2 = (Dali::Radian *)jarg2;
10224   if (!argp2) {
10225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10226     return 0;
10227   }
10228   arg2 = *argp2;
10229   {
10230     try {
10231       result = (bool)Dali::operator ==(arg1,arg2);
10232     } catch (std::out_of_range& e) {
10233       {
10234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (std::exception& e) {
10237       {
10238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10239       };
10240     } catch (Dali::DaliException e) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10243       };
10244     } catch (...) {
10245       {
10246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10247       };
10248     }
10249   }
10250
10251   jresult = result;
10252   return jresult;
10253 }
10254
10255
10256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10257   unsigned int jresult ;
10258   Dali::Radian arg1 ;
10259   Dali::Radian arg2 ;
10260   Dali::Radian *argp1 ;
10261   Dali::Radian *argp2 ;
10262   bool result;
10263
10264   argp1 = (Dali::Radian *)jarg1;
10265   if (!argp1) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg1 = *argp1;
10270   argp2 = (Dali::Radian *)jarg2;
10271   if (!argp2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10273     return 0;
10274   }
10275   arg2 = *argp2;
10276   {
10277     try {
10278       result = (bool)Dali::operator !=(arg1,arg2);
10279     } catch (std::out_of_range& e) {
10280       {
10281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (std::exception& e) {
10284       {
10285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10286       };
10287     } catch (Dali::DaliException e) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10290       };
10291     } catch (...) {
10292       {
10293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10294       };
10295     }
10296   }
10297
10298   jresult = result;
10299   return jresult;
10300 }
10301
10302
10303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10304   unsigned int jresult ;
10305   Dali::Radian arg1 ;
10306   Dali::Degree arg2 ;
10307   Dali::Radian *argp1 ;
10308   Dali::Degree *argp2 ;
10309   bool result;
10310
10311   argp1 = (Dali::Radian *)jarg1;
10312   if (!argp1) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10314     return 0;
10315   }
10316   arg1 = *argp1;
10317   argp2 = (Dali::Degree *)jarg2;
10318   if (!argp2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10320     return 0;
10321   }
10322   arg2 = *argp2;
10323   {
10324     try {
10325       result = (bool)Dali::operator ==(arg1,arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (Dali::DaliException e) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10337       };
10338     } catch (...) {
10339       {
10340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10341       };
10342     }
10343   }
10344
10345   jresult = result;
10346   return jresult;
10347 }
10348
10349
10350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10351   unsigned int jresult ;
10352   Dali::Radian arg1 ;
10353   Dali::Degree arg2 ;
10354   Dali::Radian *argp1 ;
10355   Dali::Degree *argp2 ;
10356   bool result;
10357
10358   argp1 = (Dali::Radian *)jarg1;
10359   if (!argp1) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10361     return 0;
10362   }
10363   arg1 = *argp1;
10364   argp2 = (Dali::Degree *)jarg2;
10365   if (!argp2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10367     return 0;
10368   }
10369   arg2 = *argp2;
10370   {
10371     try {
10372       result = (bool)Dali::operator !=(arg1,arg2);
10373     } catch (std::out_of_range& e) {
10374       {
10375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (std::exception& e) {
10378       {
10379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10380       };
10381     } catch (Dali::DaliException e) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10384       };
10385     } catch (...) {
10386       {
10387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10388       };
10389     }
10390   }
10391
10392   jresult = result;
10393   return jresult;
10394 }
10395
10396
10397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10398   unsigned int jresult ;
10399   Dali::Degree arg1 ;
10400   Dali::Radian arg2 ;
10401   Dali::Degree *argp1 ;
10402   Dali::Radian *argp2 ;
10403   bool result;
10404
10405   argp1 = (Dali::Degree *)jarg1;
10406   if (!argp1) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10408     return 0;
10409   }
10410   arg1 = *argp1;
10411   argp2 = (Dali::Radian *)jarg2;
10412   if (!argp2) {
10413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10414     return 0;
10415   }
10416   arg2 = *argp2;
10417   {
10418     try {
10419       result = (bool)Dali::operator ==(arg1,arg2);
10420     } catch (std::out_of_range& e) {
10421       {
10422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (std::exception& e) {
10425       {
10426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10427       };
10428     } catch (Dali::DaliException e) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10435       };
10436     }
10437   }
10438
10439   jresult = result;
10440   return jresult;
10441 }
10442
10443
10444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10445   unsigned int jresult ;
10446   Dali::Degree arg1 ;
10447   Dali::Radian arg2 ;
10448   Dali::Degree *argp1 ;
10449   Dali::Radian *argp2 ;
10450   bool result;
10451
10452   argp1 = (Dali::Degree *)jarg1;
10453   if (!argp1) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10455     return 0;
10456   }
10457   arg1 = *argp1;
10458   argp2 = (Dali::Radian *)jarg2;
10459   if (!argp2) {
10460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10461     return 0;
10462   }
10463   arg2 = *argp2;
10464   {
10465     try {
10466       result = (bool)Dali::operator !=(arg1,arg2);
10467     } catch (std::out_of_range& e) {
10468       {
10469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (std::exception& e) {
10472       {
10473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10474       };
10475     } catch (Dali::DaliException e) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10478       };
10479     } catch (...) {
10480       {
10481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10482       };
10483     }
10484   }
10485
10486   jresult = result;
10487   return jresult;
10488 }
10489
10490
10491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10492   unsigned int jresult ;
10493   Dali::Radian arg1 ;
10494   Dali::Radian arg2 ;
10495   Dali::Radian *argp1 ;
10496   Dali::Radian *argp2 ;
10497   bool result;
10498
10499   argp1 = (Dali::Radian *)jarg1;
10500   if (!argp1) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg1 = *argp1;
10505   argp2 = (Dali::Radian *)jarg2;
10506   if (!argp2) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10508     return 0;
10509   }
10510   arg2 = *argp2;
10511   {
10512     try {
10513       result = (bool)Dali::operator >(arg1,arg2);
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (Dali::DaliException e) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10525       };
10526     } catch (...) {
10527       {
10528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10529       };
10530     }
10531   }
10532
10533   jresult = result;
10534   return jresult;
10535 }
10536
10537
10538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10539   unsigned int jresult ;
10540   Dali::Radian arg1 ;
10541   Dali::Degree arg2 ;
10542   Dali::Radian *argp1 ;
10543   Dali::Degree *argp2 ;
10544   bool result;
10545
10546   argp1 = (Dali::Radian *)jarg1;
10547   if (!argp1) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10549     return 0;
10550   }
10551   arg1 = *argp1;
10552   argp2 = (Dali::Degree *)jarg2;
10553   if (!argp2) {
10554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10555     return 0;
10556   }
10557   arg2 = *argp2;
10558   {
10559     try {
10560       result = (bool)Dali::operator >(arg1,arg2);
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10568       };
10569     } catch (Dali::DaliException e) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10572       };
10573     } catch (...) {
10574       {
10575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10576       };
10577     }
10578   }
10579
10580   jresult = result;
10581   return jresult;
10582 }
10583
10584
10585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10586   unsigned int jresult ;
10587   Dali::Degree arg1 ;
10588   Dali::Radian arg2 ;
10589   Dali::Degree *argp1 ;
10590   Dali::Radian *argp2 ;
10591   bool result;
10592
10593   argp1 = (Dali::Degree *)jarg1;
10594   if (!argp1) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10596     return 0;
10597   }
10598   arg1 = *argp1;
10599   argp2 = (Dali::Radian *)jarg2;
10600   if (!argp2) {
10601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10602     return 0;
10603   }
10604   arg2 = *argp2;
10605   {
10606     try {
10607       result = (bool)Dali::operator >(arg1,arg2);
10608     } catch (std::out_of_range& e) {
10609       {
10610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (std::exception& e) {
10613       {
10614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10615       };
10616     } catch (Dali::DaliException e) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10619       };
10620     } catch (...) {
10621       {
10622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10623       };
10624     }
10625   }
10626
10627   jresult = result;
10628   return jresult;
10629 }
10630
10631
10632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10633   unsigned int jresult ;
10634   Dali::Radian arg1 ;
10635   Dali::Radian arg2 ;
10636   Dali::Radian *argp1 ;
10637   Dali::Radian *argp2 ;
10638   bool result;
10639
10640   argp1 = (Dali::Radian *)jarg1;
10641   if (!argp1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg1 = *argp1;
10646   argp2 = (Dali::Radian *)jarg2;
10647   if (!argp2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10649     return 0;
10650   }
10651   arg2 = *argp2;
10652   {
10653     try {
10654       result = (bool)Dali::operator <(arg1,arg2);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (Dali::DaliException e) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10666       };
10667     } catch (...) {
10668       {
10669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10670       };
10671     }
10672   }
10673
10674   jresult = result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10680   unsigned int jresult ;
10681   Dali::Radian arg1 ;
10682   Dali::Degree arg2 ;
10683   Dali::Radian *argp1 ;
10684   Dali::Degree *argp2 ;
10685   bool result;
10686
10687   argp1 = (Dali::Radian *)jarg1;
10688   if (!argp1) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10690     return 0;
10691   }
10692   arg1 = *argp1;
10693   argp2 = (Dali::Degree *)jarg2;
10694   if (!argp2) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10696     return 0;
10697   }
10698   arg2 = *argp2;
10699   {
10700     try {
10701       result = (bool)Dali::operator <(arg1,arg2);
10702     } catch (std::out_of_range& e) {
10703       {
10704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (std::exception& e) {
10707       {
10708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10709       };
10710     } catch (Dali::DaliException e) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10713       };
10714     } catch (...) {
10715       {
10716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10717       };
10718     }
10719   }
10720
10721   jresult = result;
10722   return jresult;
10723 }
10724
10725
10726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10727   unsigned int jresult ;
10728   Dali::Degree arg1 ;
10729   Dali::Radian arg2 ;
10730   Dali::Degree *argp1 ;
10731   Dali::Radian *argp2 ;
10732   bool result;
10733
10734   argp1 = (Dali::Degree *)jarg1;
10735   if (!argp1) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10737     return 0;
10738   }
10739   arg1 = *argp1;
10740   argp2 = (Dali::Radian *)jarg2;
10741   if (!argp2) {
10742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10743     return 0;
10744   }
10745   arg2 = *argp2;
10746   {
10747     try {
10748       result = (bool)Dali::operator <(arg1,arg2);
10749     } catch (std::out_of_range& e) {
10750       {
10751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10752       };
10753     } catch (std::exception& e) {
10754       {
10755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10756       };
10757     } catch (Dali::DaliException e) {
10758       {
10759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10760       };
10761     } catch (...) {
10762       {
10763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10764       };
10765     }
10766   }
10767
10768   jresult = result;
10769   return jresult;
10770 }
10771
10772
10773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10774   void * jresult ;
10775   Dali::Radian arg1 ;
10776   float arg2 ;
10777   Dali::Radian *argp1 ;
10778   Dali::Radian result;
10779
10780   argp1 = (Dali::Radian *)jarg1;
10781   if (!argp1) {
10782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10783     return 0;
10784   }
10785   arg1 = *argp1;
10786   arg2 = (float)jarg2;
10787   {
10788     try {
10789       result = Dali::operator *(arg1,arg2);
10790     } catch (std::out_of_range& e) {
10791       {
10792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (std::exception& e) {
10795       {
10796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10797       };
10798     } catch (Dali::DaliException e) {
10799       {
10800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10801       };
10802     } catch (...) {
10803       {
10804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10805       };
10806     }
10807   }
10808
10809   jresult = new Dali::Radian((const Dali::Radian &)result);
10810   return jresult;
10811 }
10812
10813
10814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10815   void * jresult ;
10816   Dali::Radian arg1 ;
10817   Dali::Radian *argp1 ;
10818   Dali::Radian result;
10819
10820   argp1 = (Dali::Radian *)jarg1;
10821   if (!argp1) {
10822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10823     return 0;
10824   }
10825   arg1 = *argp1;
10826   {
10827     try {
10828       result = Dali::operator -(arg1);
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (Dali::DaliException e) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10840       };
10841     } catch (...) {
10842       {
10843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10844       };
10845     }
10846   }
10847
10848   jresult = new Dali::Radian((const Dali::Radian &)result);
10849   return jresult;
10850 }
10851
10852
10853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10854   void * jresult ;
10855   Dali::Radian arg1 ;
10856   float arg2 ;
10857   float arg3 ;
10858   Dali::Radian *argp1 ;
10859   Dali::Radian result;
10860
10861   argp1 = (Dali::Radian *)jarg1;
10862   if (!argp1) {
10863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10864     return 0;
10865   }
10866   arg1 = *argp1;
10867   arg2 = (float)jarg2;
10868   arg3 = (float)jarg3;
10869   {
10870     try {
10871       result = Dali::Clamp(arg1,arg2,arg3);
10872     } catch (std::out_of_range& e) {
10873       {
10874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (std::exception& e) {
10877       {
10878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10879       };
10880     } catch (Dali::DaliException e) {
10881       {
10882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10883       };
10884     } catch (...) {
10885       {
10886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10887       };
10888     }
10889   }
10890
10891   jresult = new Dali::Radian((const Dali::Radian &)result);
10892   return jresult;
10893 }
10894
10895
10896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10897   void * jresult ;
10898   Dali::Quaternion *result = 0 ;
10899
10900   {
10901     try {
10902       result = (Dali::Quaternion *)new Dali::Quaternion();
10903     } catch (std::out_of_range& e) {
10904       {
10905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (std::exception& e) {
10908       {
10909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10910       };
10911     } catch (Dali::DaliException e) {
10912       {
10913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10914       };
10915     } catch (...) {
10916       {
10917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10918       };
10919     }
10920   }
10921
10922   jresult = (void *)result;
10923   return jresult;
10924 }
10925
10926
10927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10928   void * jresult ;
10929   Dali::Radian arg1 ;
10930   Dali::Vector3 *arg2 = 0 ;
10931   Dali::Radian *argp1 ;
10932   Dali::Quaternion *result = 0 ;
10933
10934   argp1 = (Dali::Radian *)jarg1;
10935   if (!argp1) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10937     return 0;
10938   }
10939   arg1 = *argp1;
10940   arg2 = (Dali::Vector3 *)jarg2;
10941   if (!arg2) {
10942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10943     return 0;
10944   }
10945   {
10946     try {
10947       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10948     } catch (std::out_of_range& e) {
10949       {
10950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (std::exception& e) {
10953       {
10954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (Dali::DaliException e) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10959       };
10960     } catch (...) {
10961       {
10962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10963       };
10964     }
10965   }
10966
10967   jresult = (void *)result;
10968   return jresult;
10969 }
10970
10971
10972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10974
10975   arg1 = (Dali::Quaternion *)jarg1;
10976   {
10977     try {
10978       delete arg1;
10979     } catch (std::out_of_range& e) {
10980       {
10981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10982       };
10983     } catch (std::exception& e) {
10984       {
10985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10986       };
10987     } catch (Dali::DaliException e) {
10988       {
10989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10990       };
10991     } catch (...) {
10992       {
10993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10994       };
10995     }
10996   }
10997
10998 }
10999
11000
11001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11002   void * jresult ;
11003   Dali::Quaternion *result = 0 ;
11004
11005   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11006   jresult = (void *)result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11012   unsigned int jresult ;
11013   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11014   bool result;
11015
11016   arg1 = (Dali::Quaternion *)jarg1;
11017   {
11018     try {
11019       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11020     } catch (std::out_of_range& e) {
11021       {
11022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11023       };
11024     } catch (std::exception& e) {
11025       {
11026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11027       };
11028     } catch (Dali::DaliException e) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11031       };
11032     } catch (...) {
11033       {
11034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11035       };
11036     }
11037   }
11038
11039   jresult = result;
11040   return jresult;
11041 }
11042
11043
11044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11045   unsigned int jresult ;
11046   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11047   Dali::Vector3 *arg2 = 0 ;
11048   Dali::Radian *arg3 = 0 ;
11049   bool result;
11050
11051   arg1 = (Dali::Quaternion *)jarg1;
11052   arg2 = (Dali::Vector3 *)jarg2;
11053   if (!arg2) {
11054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11055     return 0;
11056   }
11057   arg3 = (Dali::Radian *)jarg3;
11058   if (!arg3) {
11059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11060     return 0;
11061   }
11062   {
11063     try {
11064       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11065     } catch (std::out_of_range& e) {
11066       {
11067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11068       };
11069     } catch (std::exception& e) {
11070       {
11071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11072       };
11073     } catch (Dali::DaliException e) {
11074       {
11075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11076       };
11077     } catch (...) {
11078       {
11079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11080       };
11081     }
11082   }
11083
11084   jresult = result;
11085   return jresult;
11086 }
11087
11088
11089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11090   void * jresult ;
11091   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11092   Dali::Quaternion *arg2 = 0 ;
11093   Dali::Quaternion result;
11094
11095   arg1 = (Dali::Quaternion *)jarg1;
11096   arg2 = (Dali::Quaternion *)jarg2;
11097   if (!arg2) {
11098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11099     return 0;
11100   }
11101   {
11102     try {
11103       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11104     } catch (std::out_of_range& e) {
11105       {
11106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11107       };
11108     } catch (std::exception& e) {
11109       {
11110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11111       };
11112     } catch (Dali::DaliException e) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11115       };
11116     } catch (...) {
11117       {
11118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11119       };
11120     }
11121   }
11122
11123   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11124   return jresult;
11125 }
11126
11127
11128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11129   void * jresult ;
11130   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11131   Dali::Quaternion *arg2 = 0 ;
11132   Dali::Quaternion result;
11133
11134   arg1 = (Dali::Quaternion *)jarg1;
11135   arg2 = (Dali::Quaternion *)jarg2;
11136   if (!arg2) {
11137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11138     return 0;
11139   }
11140   {
11141     try {
11142       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11143     } catch (std::out_of_range& e) {
11144       {
11145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11146       };
11147     } catch (std::exception& e) {
11148       {
11149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11150       };
11151     } catch (Dali::DaliException e) {
11152       {
11153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11154       };
11155     } catch (...) {
11156       {
11157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11158       };
11159     }
11160   }
11161
11162   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11163   return jresult;
11164 }
11165
11166
11167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11168   void * jresult ;
11169   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11170   Dali::Quaternion *arg2 = 0 ;
11171   Dali::Quaternion result;
11172
11173   arg1 = (Dali::Quaternion *)jarg1;
11174   arg2 = (Dali::Quaternion *)jarg2;
11175   if (!arg2) {
11176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11177     return 0;
11178   }
11179   {
11180     try {
11181       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11182     } catch (std::out_of_range& e) {
11183       {
11184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11185       };
11186     } catch (std::exception& e) {
11187       {
11188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11189       };
11190     } catch (Dali::DaliException e) {
11191       {
11192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11193       };
11194     } catch (...) {
11195       {
11196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11197       };
11198     }
11199   }
11200
11201   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11202   return jresult;
11203 }
11204
11205
11206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11207   void * jresult ;
11208   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11209   Dali::Vector3 *arg2 = 0 ;
11210   Dali::Vector3 result;
11211
11212   arg1 = (Dali::Quaternion *)jarg1;
11213   arg2 = (Dali::Vector3 *)jarg2;
11214   if (!arg2) {
11215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11216     return 0;
11217   }
11218   {
11219     try {
11220       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11221     } catch (std::out_of_range& e) {
11222       {
11223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11224       };
11225     } catch (std::exception& e) {
11226       {
11227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11228       };
11229     } catch (Dali::DaliException e) {
11230       {
11231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11232       };
11233     } catch (...) {
11234       {
11235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11236       };
11237     }
11238   }
11239
11240   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11241   return jresult;
11242 }
11243
11244
11245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11246   void * jresult ;
11247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11248   Dali::Quaternion *arg2 = 0 ;
11249   Dali::Quaternion result;
11250
11251   arg1 = (Dali::Quaternion *)jarg1;
11252   arg2 = (Dali::Quaternion *)jarg2;
11253   if (!arg2) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11255     return 0;
11256   }
11257   {
11258     try {
11259       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11267       };
11268     } catch (Dali::DaliException e) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11271       };
11272     } catch (...) {
11273       {
11274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11275       };
11276     }
11277   }
11278
11279   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11280   return jresult;
11281 }
11282
11283
11284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11285   void * jresult ;
11286   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11287   float arg2 ;
11288   Dali::Quaternion result;
11289
11290   arg1 = (Dali::Quaternion *)jarg1;
11291   arg2 = (float)jarg2;
11292   {
11293     try {
11294       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11295     } catch (std::out_of_range& e) {
11296       {
11297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11298       };
11299     } catch (std::exception& e) {
11300       {
11301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11302       };
11303     } catch (Dali::DaliException e) {
11304       {
11305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11306       };
11307     } catch (...) {
11308       {
11309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11310       };
11311     }
11312   }
11313
11314   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11315   return jresult;
11316 }
11317
11318
11319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11320   void * jresult ;
11321   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11322   float arg2 ;
11323   Dali::Quaternion result;
11324
11325   arg1 = (Dali::Quaternion *)jarg1;
11326   arg2 = (float)jarg2;
11327   {
11328     try {
11329       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11337       };
11338     } catch (Dali::DaliException e) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11341       };
11342     } catch (...) {
11343       {
11344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11345       };
11346     }
11347   }
11348
11349   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11350   return jresult;
11351 }
11352
11353
11354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11355   void * jresult ;
11356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11357   Dali::Quaternion result;
11358
11359   arg1 = (Dali::Quaternion *)jarg1;
11360   {
11361     try {
11362       result = ((Dali::Quaternion const *)arg1)->operator -();
11363     } catch (std::out_of_range& e) {
11364       {
11365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11366       };
11367     } catch (std::exception& e) {
11368       {
11369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11370       };
11371     } catch (Dali::DaliException e) {
11372       {
11373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11374       };
11375     } catch (...) {
11376       {
11377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11378       };
11379     }
11380   }
11381
11382   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11383   return jresult;
11384 }
11385
11386
11387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11388   void * jresult ;
11389   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11390   Dali::Quaternion *arg2 = 0 ;
11391   Dali::Quaternion *result = 0 ;
11392
11393   arg1 = (Dali::Quaternion *)jarg1;
11394   arg2 = (Dali::Quaternion *)jarg2;
11395   if (!arg2) {
11396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11397     return 0;
11398   }
11399   {
11400     try {
11401       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11402     } catch (std::out_of_range& e) {
11403       {
11404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11405       };
11406     } catch (std::exception& e) {
11407       {
11408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11409       };
11410     } catch (Dali::DaliException e) {
11411       {
11412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11417       };
11418     }
11419   }
11420
11421   jresult = (void *)result;
11422   return jresult;
11423 }
11424
11425
11426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11427   void * jresult ;
11428   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11429   Dali::Quaternion *arg2 = 0 ;
11430   Dali::Quaternion *result = 0 ;
11431
11432   arg1 = (Dali::Quaternion *)jarg1;
11433   arg2 = (Dali::Quaternion *)jarg2;
11434   if (!arg2) {
11435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11436     return 0;
11437   }
11438   {
11439     try {
11440       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11441     } catch (std::out_of_range& e) {
11442       {
11443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11444       };
11445     } catch (std::exception& e) {
11446       {
11447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11448       };
11449     } catch (Dali::DaliException e) {
11450       {
11451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11452       };
11453     } catch (...) {
11454       {
11455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11456       };
11457     }
11458   }
11459
11460   jresult = (void *)result;
11461   return jresult;
11462 }
11463
11464
11465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11466   void * jresult ;
11467   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11468   Dali::Quaternion *arg2 = 0 ;
11469   Dali::Quaternion *result = 0 ;
11470
11471   arg1 = (Dali::Quaternion *)jarg1;
11472   arg2 = (Dali::Quaternion *)jarg2;
11473   if (!arg2) {
11474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11475     return 0;
11476   }
11477   {
11478     try {
11479       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11480     } catch (std::out_of_range& e) {
11481       {
11482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11483       };
11484     } catch (std::exception& e) {
11485       {
11486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11487       };
11488     } catch (Dali::DaliException e) {
11489       {
11490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11491       };
11492     } catch (...) {
11493       {
11494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11495       };
11496     }
11497   }
11498
11499   jresult = (void *)result;
11500   return jresult;
11501 }
11502
11503
11504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11505   void * jresult ;
11506   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11507   float arg2 ;
11508   Dali::Quaternion *result = 0 ;
11509
11510   arg1 = (Dali::Quaternion *)jarg1;
11511   arg2 = (float)jarg2;
11512   {
11513     try {
11514       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11515     } catch (std::out_of_range& e) {
11516       {
11517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11518       };
11519     } catch (std::exception& e) {
11520       {
11521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11522       };
11523     } catch (Dali::DaliException e) {
11524       {
11525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11526       };
11527     } catch (...) {
11528       {
11529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11530       };
11531     }
11532   }
11533
11534   jresult = (void *)result;
11535   return jresult;
11536 }
11537
11538
11539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11540   void * jresult ;
11541   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11542   float arg2 ;
11543   Dali::Quaternion *result = 0 ;
11544
11545   arg1 = (Dali::Quaternion *)jarg1;
11546   arg2 = (float)jarg2;
11547   {
11548     try {
11549       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11550     } catch (std::out_of_range& e) {
11551       {
11552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11553       };
11554     } catch (std::exception& e) {
11555       {
11556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11557       };
11558     } catch (Dali::DaliException e) {
11559       {
11560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11561       };
11562     } catch (...) {
11563       {
11564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11565       };
11566     }
11567   }
11568
11569   jresult = (void *)result;
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11575   unsigned int jresult ;
11576   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11577   Dali::Quaternion *arg2 = 0 ;
11578   bool result;
11579
11580   arg1 = (Dali::Quaternion *)jarg1;
11581   arg2 = (Dali::Quaternion *)jarg2;
11582   if (!arg2) {
11583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11584     return 0;
11585   }
11586   {
11587     try {
11588       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11589     } catch (std::out_of_range& e) {
11590       {
11591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11592       };
11593     } catch (std::exception& e) {
11594       {
11595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11596       };
11597     } catch (Dali::DaliException e) {
11598       {
11599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11600       };
11601     } catch (...) {
11602       {
11603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11604       };
11605     }
11606   }
11607
11608   jresult = result;
11609   return jresult;
11610 }
11611
11612
11613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11614   unsigned int jresult ;
11615   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11616   Dali::Quaternion *arg2 = 0 ;
11617   bool result;
11618
11619   arg1 = (Dali::Quaternion *)jarg1;
11620   arg2 = (Dali::Quaternion *)jarg2;
11621   if (!arg2) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11623     return 0;
11624   }
11625   {
11626     try {
11627       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11628     } catch (std::out_of_range& e) {
11629       {
11630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11631       };
11632     } catch (std::exception& e) {
11633       {
11634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11635       };
11636     } catch (Dali::DaliException e) {
11637       {
11638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11643       };
11644     }
11645   }
11646
11647   jresult = result;
11648   return jresult;
11649 }
11650
11651
11652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11653   float jresult ;
11654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11655   float result;
11656
11657   arg1 = (Dali::Quaternion *)jarg1;
11658   {
11659     try {
11660       result = (float)((Dali::Quaternion const *)arg1)->Length();
11661     } catch (std::out_of_range& e) {
11662       {
11663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11664       };
11665     } catch (std::exception& e) {
11666       {
11667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11668       };
11669     } catch (Dali::DaliException e) {
11670       {
11671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11672       };
11673     } catch (...) {
11674       {
11675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11676       };
11677     }
11678   }
11679
11680   jresult = result;
11681   return jresult;
11682 }
11683
11684
11685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11686   float jresult ;
11687   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11688   float result;
11689
11690   arg1 = (Dali::Quaternion *)jarg1;
11691   {
11692     try {
11693       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11694     } catch (std::out_of_range& e) {
11695       {
11696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11697       };
11698     } catch (std::exception& e) {
11699       {
11700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11701       };
11702     } catch (Dali::DaliException e) {
11703       {
11704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11705       };
11706     } catch (...) {
11707       {
11708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11709       };
11710     }
11711   }
11712
11713   jresult = result;
11714   return jresult;
11715 }
11716
11717
11718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11719   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11720
11721   arg1 = (Dali::Quaternion *)jarg1;
11722   {
11723     try {
11724       (arg1)->Normalize();
11725     } catch (std::out_of_range& e) {
11726       {
11727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11728       };
11729     } catch (std::exception& e) {
11730       {
11731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11732       };
11733     } catch (Dali::DaliException e) {
11734       {
11735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11736       };
11737     } catch (...) {
11738       {
11739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11740       };
11741     }
11742   }
11743
11744 }
11745
11746
11747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11748   void * jresult ;
11749   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11750   Dali::Quaternion result;
11751
11752   arg1 = (Dali::Quaternion *)jarg1;
11753   {
11754     try {
11755       result = ((Dali::Quaternion const *)arg1)->Normalized();
11756     } catch (std::out_of_range& e) {
11757       {
11758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11759       };
11760     } catch (std::exception& e) {
11761       {
11762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11763       };
11764     } catch (Dali::DaliException e) {
11765       {
11766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11767       };
11768     } catch (...) {
11769       {
11770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11771       };
11772     }
11773   }
11774
11775   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11776   return jresult;
11777 }
11778
11779
11780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11781   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11782
11783   arg1 = (Dali::Quaternion *)jarg1;
11784   {
11785     try {
11786       (arg1)->Conjugate();
11787     } catch (std::out_of_range& e) {
11788       {
11789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11790       };
11791     } catch (std::exception& e) {
11792       {
11793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11794       };
11795     } catch (Dali::DaliException e) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11798       };
11799     } catch (...) {
11800       {
11801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11802       };
11803     }
11804   }
11805
11806 }
11807
11808
11809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11810   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11811
11812   arg1 = (Dali::Quaternion *)jarg1;
11813   {
11814     try {
11815       (arg1)->Invert();
11816     } catch (std::out_of_range& e) {
11817       {
11818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11819       };
11820     } catch (std::exception& e) {
11821       {
11822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11823       };
11824     } catch (Dali::DaliException e) {
11825       {
11826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11827       };
11828     } catch (...) {
11829       {
11830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11831       };
11832     }
11833   }
11834
11835 }
11836
11837
11838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11839   void * jresult ;
11840   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11841   Dali::Quaternion result;
11842
11843   arg1 = (Dali::Quaternion *)jarg1;
11844   {
11845     try {
11846       result = ((Dali::Quaternion const *)arg1)->Log();
11847     } catch (std::out_of_range& e) {
11848       {
11849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11850       };
11851     } catch (std::exception& e) {
11852       {
11853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11854       };
11855     } catch (Dali::DaliException e) {
11856       {
11857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11858       };
11859     } catch (...) {
11860       {
11861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11862       };
11863     }
11864   }
11865
11866   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11867   return jresult;
11868 }
11869
11870
11871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11872   void * jresult ;
11873   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11874   Dali::Quaternion result;
11875
11876   arg1 = (Dali::Quaternion *)jarg1;
11877   {
11878     try {
11879       result = ((Dali::Quaternion const *)arg1)->Exp();
11880     } catch (std::out_of_range& e) {
11881       {
11882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11883       };
11884     } catch (std::exception& e) {
11885       {
11886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11887       };
11888     } catch (Dali::DaliException e) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11891       };
11892     } catch (...) {
11893       {
11894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11895       };
11896     }
11897   }
11898
11899   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11900   return jresult;
11901 }
11902
11903
11904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11905   float jresult ;
11906   Dali::Quaternion *arg1 = 0 ;
11907   Dali::Quaternion *arg2 = 0 ;
11908   float result;
11909
11910   arg1 = (Dali::Quaternion *)jarg1;
11911   if (!arg1) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   arg2 = (Dali::Quaternion *)jarg2;
11916   if (!arg2) {
11917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11918     return 0;
11919   }
11920   {
11921     try {
11922       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11923     } catch (std::out_of_range& e) {
11924       {
11925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11926       };
11927     } catch (std::exception& e) {
11928       {
11929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11930       };
11931     } catch (Dali::DaliException e) {
11932       {
11933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11934       };
11935     } catch (...) {
11936       {
11937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11938       };
11939     }
11940   }
11941
11942   jresult = result;
11943   return jresult;
11944 }
11945
11946
11947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11948   void * jresult ;
11949   Dali::Quaternion *arg1 = 0 ;
11950   Dali::Quaternion *arg2 = 0 ;
11951   float arg3 ;
11952   Dali::Quaternion result;
11953
11954   arg1 = (Dali::Quaternion *)jarg1;
11955   if (!arg1) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg2 = (Dali::Quaternion *)jarg2;
11960   if (!arg2) {
11961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11962     return 0;
11963   }
11964   arg3 = (float)jarg3;
11965   {
11966     try {
11967       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11968     } catch (std::out_of_range& e) {
11969       {
11970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11971       };
11972     } catch (std::exception& e) {
11973       {
11974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (Dali::DaliException e) {
11977       {
11978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11979       };
11980     } catch (...) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11983       };
11984     }
11985   }
11986
11987   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11988   return jresult;
11989 }
11990
11991
11992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11993   void * jresult ;
11994   Dali::Quaternion *arg1 = 0 ;
11995   Dali::Quaternion *arg2 = 0 ;
11996   float arg3 ;
11997   Dali::Quaternion result;
11998
11999   arg1 = (Dali::Quaternion *)jarg1;
12000   if (!arg1) {
12001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12002     return 0;
12003   }
12004   arg2 = (Dali::Quaternion *)jarg2;
12005   if (!arg2) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12007     return 0;
12008   }
12009   arg3 = (float)jarg3;
12010   {
12011     try {
12012       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (Dali::DaliException e) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12024       };
12025     } catch (...) {
12026       {
12027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12028       };
12029     }
12030   }
12031
12032   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12033   return jresult;
12034 }
12035
12036
12037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12038   void * jresult ;
12039   Dali::Quaternion *arg1 = 0 ;
12040   Dali::Quaternion *arg2 = 0 ;
12041   float arg3 ;
12042   Dali::Quaternion result;
12043
12044   arg1 = (Dali::Quaternion *)jarg1;
12045   if (!arg1) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg2 = (Dali::Quaternion *)jarg2;
12050   if (!arg2) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg3 = (float)jarg3;
12055   {
12056     try {
12057       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12058     } catch (std::out_of_range& e) {
12059       {
12060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12061       };
12062     } catch (std::exception& e) {
12063       {
12064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12065       };
12066     } catch (Dali::DaliException e) {
12067       {
12068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12069       };
12070     } catch (...) {
12071       {
12072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12073       };
12074     }
12075   }
12076
12077   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12078   return jresult;
12079 }
12080
12081
12082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12083   void * jresult ;
12084   Dali::Quaternion *arg1 = 0 ;
12085   Dali::Quaternion *arg2 = 0 ;
12086   Dali::Quaternion *arg3 = 0 ;
12087   Dali::Quaternion *arg4 = 0 ;
12088   float arg5 ;
12089   Dali::Quaternion result;
12090
12091   arg1 = (Dali::Quaternion *)jarg1;
12092   if (!arg1) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12094     return 0;
12095   }
12096   arg2 = (Dali::Quaternion *)jarg2;
12097   if (!arg2) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg3 = (Dali::Quaternion *)jarg3;
12102   if (!arg3) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg4 = (Dali::Quaternion *)jarg4;
12107   if (!arg4) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12109     return 0;
12110   }
12111   arg5 = (float)jarg5;
12112   {
12113     try {
12114       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12122       };
12123     } catch (Dali::DaliException e) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12126       };
12127     } catch (...) {
12128       {
12129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12130       };
12131     }
12132   }
12133
12134   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12135   return jresult;
12136 }
12137
12138
12139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12140   float jresult ;
12141   Dali::Quaternion *arg1 = 0 ;
12142   Dali::Quaternion *arg2 = 0 ;
12143   float result;
12144
12145   arg1 = (Dali::Quaternion *)jarg1;
12146   if (!arg1) {
12147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12148     return 0;
12149   }
12150   arg2 = (Dali::Quaternion *)jarg2;
12151   if (!arg2) {
12152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12153     return 0;
12154   }
12155   {
12156     try {
12157       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12158     } catch (std::out_of_range& e) {
12159       {
12160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12161       };
12162     } catch (std::exception& e) {
12163       {
12164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12165       };
12166     } catch (Dali::DaliException e) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12169       };
12170     } catch (...) {
12171       {
12172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12173       };
12174     }
12175   }
12176
12177   jresult = result;
12178   return jresult;
12179 }
12180
12181
12182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12183   void * jresult ;
12184   Dali::Matrix *result = 0 ;
12185
12186   {
12187     try {
12188       result = (Dali::Matrix *)new Dali::Matrix();
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (Dali::DaliException e) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207
12208   jresult = (void *)result;
12209   return jresult;
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12214   void * jresult ;
12215   bool arg1 ;
12216   Dali::Matrix *result = 0 ;
12217
12218   arg1 = jarg1 ? true : false;
12219   {
12220     try {
12221       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12229       };
12230     } catch (Dali::DaliException e) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12233       };
12234     } catch (...) {
12235       {
12236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12237       };
12238     }
12239   }
12240
12241   jresult = (void *)result;
12242   return jresult;
12243 }
12244
12245
12246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12247   void * jresult ;
12248   float *arg1 = (float *) 0 ;
12249   Dali::Matrix *result = 0 ;
12250
12251   arg1 = jarg1;
12252   {
12253     try {
12254       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12255     } catch (std::out_of_range& e) {
12256       {
12257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12258       };
12259     } catch (std::exception& e) {
12260       {
12261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12262       };
12263     } catch (Dali::DaliException e) {
12264       {
12265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12266       };
12267     } catch (...) {
12268       {
12269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12270       };
12271     }
12272   }
12273
12274   jresult = (void *)result;
12275
12276
12277   return jresult;
12278 }
12279
12280
12281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12282   void * jresult ;
12283   Dali::Quaternion *arg1 = 0 ;
12284   Dali::Matrix *result = 0 ;
12285
12286   arg1 = (Dali::Quaternion *)jarg1;
12287   if (!arg1) {
12288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12289     return 0;
12290   }
12291   {
12292     try {
12293       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12294     } catch (std::out_of_range& e) {
12295       {
12296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12297       };
12298     } catch (std::exception& e) {
12299       {
12300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12301       };
12302     } catch (Dali::DaliException e) {
12303       {
12304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12305       };
12306     } catch (...) {
12307       {
12308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12309       };
12310     }
12311   }
12312
12313   jresult = (void *)result;
12314   return jresult;
12315 }
12316
12317
12318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12319   void * jresult ;
12320   Dali::Matrix *arg1 = 0 ;
12321   Dali::Matrix *result = 0 ;
12322
12323   arg1 = (Dali::Matrix *)jarg1;
12324   if (!arg1) {
12325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12326     return 0;
12327   }
12328   {
12329     try {
12330       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12331     } catch (std::out_of_range& e) {
12332       {
12333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12334       };
12335     } catch (std::exception& e) {
12336       {
12337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12338       };
12339     } catch (Dali::DaliException e) {
12340       {
12341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12342       };
12343     } catch (...) {
12344       {
12345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12346       };
12347     }
12348   }
12349
12350   jresult = (void *)result;
12351   return jresult;
12352 }
12353
12354
12355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12356   void * jresult ;
12357   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12358   Dali::Matrix *arg2 = 0 ;
12359   Dali::Matrix *result = 0 ;
12360
12361   arg1 = (Dali::Matrix *)jarg1;
12362   arg2 = (Dali::Matrix *)jarg2;
12363   if (!arg2) {
12364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12365     return 0;
12366   }
12367   {
12368     try {
12369       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12370     } catch (std::out_of_range& e) {
12371       {
12372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12373       };
12374     } catch (std::exception& e) {
12375       {
12376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12377       };
12378     } catch (Dali::DaliException e) {
12379       {
12380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12381       };
12382     } catch (...) {
12383       {
12384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12385       };
12386     }
12387   }
12388
12389   jresult = (void *)result;
12390   return jresult;
12391 }
12392
12393
12394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12395   void * jresult ;
12396   Dali::Matrix *result = 0 ;
12397
12398   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12399   jresult = (void *)result;
12400   return jresult;
12401 }
12402
12403
12404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12405   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12406
12407   arg1 = (Dali::Matrix *)jarg1;
12408   {
12409     try {
12410       (arg1)->SetIdentity();
12411     } catch (std::out_of_range& e) {
12412       {
12413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12414       };
12415     } catch (std::exception& e) {
12416       {
12417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12418       };
12419     } catch (Dali::DaliException e) {
12420       {
12421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12422       };
12423     } catch (...) {
12424       {
12425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12426       };
12427     }
12428   }
12429
12430 }
12431
12432
12433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12434   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12435   Dali::Vector3 *arg2 = 0 ;
12436
12437   arg1 = (Dali::Matrix *)jarg1;
12438   arg2 = (Dali::Vector3 *)jarg2;
12439   if (!arg2) {
12440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12441     return ;
12442   }
12443   {
12444     try {
12445       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12446     } catch (std::out_of_range& e) {
12447       {
12448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12449       };
12450     } catch (std::exception& e) {
12451       {
12452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12453       };
12454     } catch (Dali::DaliException e) {
12455       {
12456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12457       };
12458     } catch (...) {
12459       {
12460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12461       };
12462     }
12463   }
12464
12465 }
12466
12467
12468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12469   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12470   Dali::Matrix *arg2 = 0 ;
12471
12472   arg1 = (Dali::Matrix *)jarg1;
12473   arg2 = (Dali::Matrix *)jarg2;
12474   if (!arg2) {
12475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12476     return ;
12477   }
12478   {
12479     try {
12480       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12481     } catch (std::out_of_range& e) {
12482       {
12483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12484       };
12485     } catch (std::exception& e) {
12486       {
12487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12488       };
12489     } catch (Dali::DaliException e) {
12490       {
12491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12492       };
12493     } catch (...) {
12494       {
12495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12496       };
12497     }
12498   }
12499
12500 }
12501
12502
12503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12504   unsigned int jresult ;
12505   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12506   bool result;
12507
12508   arg1 = (Dali::Matrix *)jarg1;
12509   {
12510     try {
12511       result = (bool)(arg1)->Invert();
12512     } catch (std::out_of_range& e) {
12513       {
12514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12515       };
12516     } catch (std::exception& e) {
12517       {
12518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12519       };
12520     } catch (Dali::DaliException e) {
12521       {
12522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12523       };
12524     } catch (...) {
12525       {
12526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12527       };
12528     }
12529   }
12530
12531   jresult = result;
12532   return jresult;
12533 }
12534
12535
12536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12537   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12538
12539   arg1 = (Dali::Matrix *)jarg1;
12540   {
12541     try {
12542       (arg1)->Transpose();
12543     } catch (std::out_of_range& e) {
12544       {
12545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12546       };
12547     } catch (std::exception& e) {
12548       {
12549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12550       };
12551     } catch (Dali::DaliException e) {
12552       {
12553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12554       };
12555     } catch (...) {
12556       {
12557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12558       };
12559     }
12560   }
12561
12562 }
12563
12564
12565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12566   void * jresult ;
12567   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12568   Dali::Vector3 result;
12569
12570   arg1 = (Dali::Matrix *)jarg1;
12571   {
12572     try {
12573       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12574     } catch (std::out_of_range& e) {
12575       {
12576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12577       };
12578     } catch (std::exception& e) {
12579       {
12580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12581       };
12582     } catch (Dali::DaliException e) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12585       };
12586     } catch (...) {
12587       {
12588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12589       };
12590     }
12591   }
12592
12593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12594   return jresult;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12599   void * jresult ;
12600   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12601   Dali::Vector3 result;
12602
12603   arg1 = (Dali::Matrix *)jarg1;
12604   {
12605     try {
12606       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12607     } catch (std::out_of_range& e) {
12608       {
12609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12610       };
12611     } catch (std::exception& e) {
12612       {
12613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12614       };
12615     } catch (Dali::DaliException e) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12622       };
12623     }
12624   }
12625
12626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12632   void * jresult ;
12633   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12634   Dali::Vector3 result;
12635
12636   arg1 = (Dali::Matrix *)jarg1;
12637   {
12638     try {
12639       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12640     } catch (std::out_of_range& e) {
12641       {
12642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12643       };
12644     } catch (std::exception& e) {
12645       {
12646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12647       };
12648     } catch (Dali::DaliException e) {
12649       {
12650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12651       };
12652     } catch (...) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12655       };
12656     }
12657   }
12658
12659   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12660   return jresult;
12661 }
12662
12663
12664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12665   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12666   Dali::Vector3 *arg2 = 0 ;
12667
12668   arg1 = (Dali::Matrix *)jarg1;
12669   arg2 = (Dali::Vector3 *)jarg2;
12670   if (!arg2) {
12671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12672     return ;
12673   }
12674   {
12675     try {
12676       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12677     } catch (std::out_of_range& e) {
12678       {
12679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12680       };
12681     } catch (std::exception& e) {
12682       {
12683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12684       };
12685     } catch (Dali::DaliException e) {
12686       {
12687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12688       };
12689     } catch (...) {
12690       {
12691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12692       };
12693     }
12694   }
12695
12696 }
12697
12698
12699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12701   Dali::Vector3 *arg2 = 0 ;
12702
12703   arg1 = (Dali::Matrix *)jarg1;
12704   arg2 = (Dali::Vector3 *)jarg2;
12705   if (!arg2) {
12706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12707     return ;
12708   }
12709   {
12710     try {
12711       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12712     } catch (std::out_of_range& e) {
12713       {
12714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12715       };
12716     } catch (std::exception& e) {
12717       {
12718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12719       };
12720     } catch (Dali::DaliException e) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12723       };
12724     } catch (...) {
12725       {
12726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12727       };
12728     }
12729   }
12730
12731 }
12732
12733
12734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12736   Dali::Vector3 *arg2 = 0 ;
12737
12738   arg1 = (Dali::Matrix *)jarg1;
12739   arg2 = (Dali::Vector3 *)jarg2;
12740   if (!arg2) {
12741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12742     return ;
12743   }
12744   {
12745     try {
12746       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12747     } catch (std::out_of_range& e) {
12748       {
12749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12750       };
12751     } catch (std::exception& e) {
12752       {
12753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12754       };
12755     } catch (Dali::DaliException e) {
12756       {
12757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12758       };
12759     } catch (...) {
12760       {
12761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12762       };
12763     }
12764   }
12765
12766 }
12767
12768
12769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12770   void * jresult ;
12771   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12772   Dali::Vector4 *result = 0 ;
12773
12774   arg1 = (Dali::Matrix *)jarg1;
12775   {
12776     try {
12777       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12778     } catch (std::out_of_range& e) {
12779       {
12780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (std::exception& e) {
12783       {
12784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12785       };
12786     } catch (Dali::DaliException e) {
12787       {
12788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12789       };
12790     } catch (...) {
12791       {
12792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12793       };
12794     }
12795   }
12796
12797   jresult = (void *)result;
12798   return jresult;
12799 }
12800
12801
12802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12803   void * jresult ;
12804   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12805   Dali::Vector3 *result = 0 ;
12806
12807   arg1 = (Dali::Matrix *)jarg1;
12808   {
12809     try {
12810       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12811     } catch (std::out_of_range& e) {
12812       {
12813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12814       };
12815     } catch (std::exception& e) {
12816       {
12817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12818       };
12819     } catch (Dali::DaliException e) {
12820       {
12821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12822       };
12823     } catch (...) {
12824       {
12825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12826       };
12827     }
12828   }
12829
12830   jresult = (void *)result;
12831   return jresult;
12832 }
12833
12834
12835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12836   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12837   Dali::Vector4 *arg2 = 0 ;
12838
12839   arg1 = (Dali::Matrix *)jarg1;
12840   arg2 = (Dali::Vector4 *)jarg2;
12841   if (!arg2) {
12842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12843     return ;
12844   }
12845   {
12846     try {
12847       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12848     } catch (std::out_of_range& e) {
12849       {
12850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12851       };
12852     } catch (std::exception& e) {
12853       {
12854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12855       };
12856     } catch (Dali::DaliException e) {
12857       {
12858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12859       };
12860     } catch (...) {
12861       {
12862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12863       };
12864     }
12865   }
12866
12867 }
12868
12869
12870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12871   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12872   Dali::Vector3 *arg2 = 0 ;
12873
12874   arg1 = (Dali::Matrix *)jarg1;
12875   arg2 = (Dali::Vector3 *)jarg2;
12876   if (!arg2) {
12877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12878     return ;
12879   }
12880   {
12881     try {
12882       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12883     } catch (std::out_of_range& e) {
12884       {
12885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12886       };
12887     } catch (std::exception& e) {
12888       {
12889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12890       };
12891     } catch (Dali::DaliException e) {
12892       {
12893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12894       };
12895     } catch (...) {
12896       {
12897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12898       };
12899     }
12900   }
12901
12902 }
12903
12904
12905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12906   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12907
12908   arg1 = (Dali::Matrix *)jarg1;
12909   {
12910     try {
12911       (arg1)->OrthoNormalize();
12912     } catch (std::out_of_range& e) {
12913       {
12914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12915       };
12916     } catch (std::exception& e) {
12917       {
12918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12919       };
12920     } catch (Dali::DaliException e) {
12921       {
12922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12923       };
12924     } catch (...) {
12925       {
12926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12927       };
12928     }
12929   }
12930
12931 }
12932
12933
12934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12935   void * jresult ;
12936   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12937   float *result = 0 ;
12938
12939   arg1 = (Dali::Matrix *)jarg1;
12940   {
12941     try {
12942       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12943     } catch (std::out_of_range& e) {
12944       {
12945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12946       };
12947     } catch (std::exception& e) {
12948       {
12949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12950       };
12951     } catch (Dali::DaliException e) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12958       };
12959     }
12960   }
12961
12962   jresult = (void *)result;
12963   return jresult;
12964 }
12965
12966
12967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12968   Dali::Matrix *arg1 = 0 ;
12969   Dali::Matrix *arg2 = 0 ;
12970   Dali::Matrix *arg3 = 0 ;
12971
12972   arg1 = (Dali::Matrix *)jarg1;
12973   if (!arg1) {
12974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12975     return ;
12976   }
12977   arg2 = (Dali::Matrix *)jarg2;
12978   if (!arg2) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12980     return ;
12981   }
12982   arg3 = (Dali::Matrix *)jarg3;
12983   if (!arg3) {
12984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12985     return ;
12986   }
12987   {
12988     try {
12989       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12990     } catch (std::out_of_range& e) {
12991       {
12992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12993       };
12994     } catch (std::exception& e) {
12995       {
12996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12997       };
12998     } catch (Dali::DaliException e) {
12999       {
13000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13001       };
13002     } catch (...) {
13003       {
13004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13005       };
13006     }
13007   }
13008
13009 }
13010
13011
13012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13013   Dali::Matrix *arg1 = 0 ;
13014   Dali::Matrix *arg2 = 0 ;
13015   Dali::Quaternion *arg3 = 0 ;
13016
13017   arg1 = (Dali::Matrix *)jarg1;
13018   if (!arg1) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13020     return ;
13021   }
13022   arg2 = (Dali::Matrix *)jarg2;
13023   if (!arg2) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13025     return ;
13026   }
13027   arg3 = (Dali::Quaternion *)jarg3;
13028   if (!arg3) {
13029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13030     return ;
13031   }
13032   {
13033     try {
13034       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13035     } catch (std::out_of_range& e) {
13036       {
13037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13038       };
13039     } catch (std::exception& e) {
13040       {
13041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13042       };
13043     } catch (Dali::DaliException e) {
13044       {
13045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13046       };
13047     } catch (...) {
13048       {
13049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13050       };
13051     }
13052   }
13053
13054 }
13055
13056
13057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13058   void * jresult ;
13059   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13060   Dali::Vector4 *arg2 = 0 ;
13061   Dali::Vector4 result;
13062
13063   arg1 = (Dali::Matrix *)jarg1;
13064   arg2 = (Dali::Vector4 *)jarg2;
13065   if (!arg2) {
13066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13067     return 0;
13068   }
13069   {
13070     try {
13071       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13072     } catch (std::out_of_range& e) {
13073       {
13074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13075       };
13076     } catch (std::exception& e) {
13077       {
13078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13079       };
13080     } catch (Dali::DaliException e) {
13081       {
13082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13083       };
13084     } catch (...) {
13085       {
13086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13087       };
13088     }
13089   }
13090
13091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13092   return jresult;
13093 }
13094
13095
13096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13097   unsigned int jresult ;
13098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13099   Dali::Matrix *arg2 = 0 ;
13100   bool result;
13101
13102   arg1 = (Dali::Matrix *)jarg1;
13103   arg2 = (Dali::Matrix *)jarg2;
13104   if (!arg2) {
13105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13106     return 0;
13107   }
13108   {
13109     try {
13110       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13111     } catch (std::out_of_range& e) {
13112       {
13113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13114       };
13115     } catch (std::exception& e) {
13116       {
13117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13118       };
13119     } catch (Dali::DaliException e) {
13120       {
13121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13122       };
13123     } catch (...) {
13124       {
13125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13126       };
13127     }
13128   }
13129
13130   jresult = result;
13131   return jresult;
13132 }
13133
13134
13135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13136   unsigned int jresult ;
13137   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13138   Dali::Matrix *arg2 = 0 ;
13139   bool result;
13140
13141   arg1 = (Dali::Matrix *)jarg1;
13142   arg2 = (Dali::Matrix *)jarg2;
13143   if (!arg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13145     return 0;
13146   }
13147   {
13148     try {
13149       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13157       };
13158     } catch (Dali::DaliException e) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13161       };
13162     } catch (...) {
13163       {
13164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13165       };
13166     }
13167   }
13168
13169   jresult = result;
13170   return jresult;
13171 }
13172
13173
13174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13175   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13176   Dali::Vector3 *arg2 = 0 ;
13177   Dali::Quaternion *arg3 = 0 ;
13178   Dali::Vector3 *arg4 = 0 ;
13179
13180   arg1 = (Dali::Matrix *)jarg1;
13181   arg2 = (Dali::Vector3 *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13184     return ;
13185   }
13186   arg3 = (Dali::Quaternion *)jarg3;
13187   if (!arg3) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13189     return ;
13190   }
13191   arg4 = (Dali::Vector3 *)jarg4;
13192   if (!arg4) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13194     return ;
13195   }
13196   {
13197     try {
13198       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13199     } catch (std::out_of_range& e) {
13200       {
13201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (std::exception& e) {
13204       {
13205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13206       };
13207     } catch (Dali::DaliException e) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13210       };
13211     } catch (...) {
13212       {
13213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13214       };
13215     }
13216   }
13217
13218 }
13219
13220
13221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13222   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13223   Dali::Vector3 *arg2 = 0 ;
13224   Dali::Quaternion *arg3 = 0 ;
13225   Dali::Vector3 *arg4 = 0 ;
13226
13227   arg1 = (Dali::Matrix *)jarg1;
13228   arg2 = (Dali::Vector3 *)jarg2;
13229   if (!arg2) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13231     return ;
13232   }
13233   arg3 = (Dali::Quaternion *)jarg3;
13234   if (!arg3) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13236     return ;
13237   }
13238   arg4 = (Dali::Vector3 *)jarg4;
13239   if (!arg4) {
13240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13241     return ;
13242   }
13243   {
13244     try {
13245       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13246     } catch (std::out_of_range& e) {
13247       {
13248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13249       };
13250     } catch (std::exception& e) {
13251       {
13252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13253       };
13254     } catch (Dali::DaliException e) {
13255       {
13256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13257       };
13258     } catch (...) {
13259       {
13260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13261       };
13262     }
13263   }
13264
13265 }
13266
13267
13268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13269   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13270   Dali::Vector3 *arg2 = 0 ;
13271   Dali::Vector3 *arg3 = 0 ;
13272   Dali::Vector3 *arg4 = 0 ;
13273   Dali::Vector3 *arg5 = 0 ;
13274
13275   arg1 = (Dali::Matrix *)jarg1;
13276   arg2 = (Dali::Vector3 *)jarg2;
13277   if (!arg2) {
13278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13279     return ;
13280   }
13281   arg3 = (Dali::Vector3 *)jarg3;
13282   if (!arg3) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg4 = (Dali::Vector3 *)jarg4;
13287   if (!arg4) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   arg5 = (Dali::Vector3 *)jarg5;
13292   if (!arg5) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13294     return ;
13295   }
13296   {
13297     try {
13298       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13299     } catch (std::out_of_range& e) {
13300       {
13301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (std::exception& e) {
13304       {
13305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13306       };
13307     } catch (Dali::DaliException e) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13310       };
13311     } catch (...) {
13312       {
13313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13314       };
13315     }
13316   }
13317
13318 }
13319
13320
13321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13322   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13323   Dali::Vector3 *arg2 = 0 ;
13324   Dali::Quaternion *arg3 = 0 ;
13325   Dali::Vector3 *arg4 = 0 ;
13326
13327   arg1 = (Dali::Matrix *)jarg1;
13328   arg2 = (Dali::Vector3 *)jarg2;
13329   if (!arg2) {
13330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13331     return ;
13332   }
13333   arg3 = (Dali::Quaternion *)jarg3;
13334   if (!arg3) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13336     return ;
13337   }
13338   arg4 = (Dali::Vector3 *)jarg4;
13339   if (!arg4) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13341     return ;
13342   }
13343   {
13344     try {
13345       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13346     } catch (std::out_of_range& e) {
13347       {
13348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (std::exception& e) {
13351       {
13352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13353       };
13354     } catch (Dali::DaliException e) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13357       };
13358     } catch (...) {
13359       {
13360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13361       };
13362     }
13363   }
13364
13365 }
13366
13367
13368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13369   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13370
13371   arg1 = (Dali::Matrix *)jarg1;
13372   {
13373     try {
13374       delete arg1;
13375     } catch (std::out_of_range& e) {
13376       {
13377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13378       };
13379     } catch (std::exception& e) {
13380       {
13381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13382       };
13383     } catch (Dali::DaliException e) {
13384       {
13385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13386       };
13387     } catch (...) {
13388       {
13389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13390       };
13391     }
13392   }
13393
13394 }
13395
13396
13397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13398   void * jresult ;
13399   Dali::Matrix3 *result = 0 ;
13400
13401   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13402   jresult = (void *)result;
13403   return jresult;
13404 }
13405
13406
13407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13408   void * jresult ;
13409   Dali::Matrix3 *result = 0 ;
13410
13411   {
13412     try {
13413       result = (Dali::Matrix3 *)new Dali::Matrix3();
13414     } catch (std::out_of_range& e) {
13415       {
13416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13417       };
13418     } catch (std::exception& e) {
13419       {
13420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (Dali::DaliException e) {
13423       {
13424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13425       };
13426     } catch (...) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13429       };
13430     }
13431   }
13432
13433   jresult = (void *)result;
13434   return jresult;
13435 }
13436
13437
13438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13439   void * jresult ;
13440   Dali::Matrix3 *arg1 = 0 ;
13441   Dali::Matrix3 *result = 0 ;
13442
13443   arg1 = (Dali::Matrix3 *)jarg1;
13444   if (!arg1) {
13445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13446     return 0;
13447   }
13448   {
13449     try {
13450       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13451     } catch (std::out_of_range& e) {
13452       {
13453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13454       };
13455     } catch (std::exception& e) {
13456       {
13457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13458       };
13459     } catch (Dali::DaliException e) {
13460       {
13461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13462       };
13463     } catch (...) {
13464       {
13465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13466       };
13467     }
13468   }
13469
13470   jresult = (void *)result;
13471   return jresult;
13472 }
13473
13474
13475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13476   void * jresult ;
13477   Dali::Matrix *arg1 = 0 ;
13478   Dali::Matrix3 *result = 0 ;
13479
13480   arg1 = (Dali::Matrix *)jarg1;
13481   if (!arg1) {
13482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13483     return 0;
13484   }
13485   {
13486     try {
13487       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13488     } catch (std::out_of_range& e) {
13489       {
13490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (std::exception& e) {
13493       {
13494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13495       };
13496     } catch (Dali::DaliException e) {
13497       {
13498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13499       };
13500     } catch (...) {
13501       {
13502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13503       };
13504     }
13505   }
13506
13507   jresult = (void *)result;
13508   return jresult;
13509 }
13510
13511
13512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13513   void * jresult ;
13514   float arg1 ;
13515   float arg2 ;
13516   float arg3 ;
13517   float arg4 ;
13518   float arg5 ;
13519   float arg6 ;
13520   float arg7 ;
13521   float arg8 ;
13522   float arg9 ;
13523   Dali::Matrix3 *result = 0 ;
13524
13525   arg1 = (float)jarg1;
13526   arg2 = (float)jarg2;
13527   arg3 = (float)jarg3;
13528   arg4 = (float)jarg4;
13529   arg5 = (float)jarg5;
13530   arg6 = (float)jarg6;
13531   arg7 = (float)jarg7;
13532   arg8 = (float)jarg8;
13533   arg9 = (float)jarg9;
13534   {
13535     try {
13536       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13537     } catch (std::out_of_range& e) {
13538       {
13539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13540       };
13541     } catch (std::exception& e) {
13542       {
13543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13544       };
13545     } catch (Dali::DaliException e) {
13546       {
13547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13548       };
13549     } catch (...) {
13550       {
13551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13552       };
13553     }
13554   }
13555
13556   jresult = (void *)result;
13557   return jresult;
13558 }
13559
13560
13561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13562   void * jresult ;
13563   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13564   Dali::Matrix3 *arg2 = 0 ;
13565   Dali::Matrix3 *result = 0 ;
13566
13567   arg1 = (Dali::Matrix3 *)jarg1;
13568   arg2 = (Dali::Matrix3 *)jarg2;
13569   if (!arg2) {
13570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13571     return 0;
13572   }
13573   {
13574     try {
13575       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13576     } catch (std::out_of_range& e) {
13577       {
13578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13579       };
13580     } catch (std::exception& e) {
13581       {
13582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13583       };
13584     } catch (Dali::DaliException e) {
13585       {
13586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13587       };
13588     } catch (...) {
13589       {
13590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13591       };
13592     }
13593   }
13594
13595   jresult = (void *)result;
13596   return jresult;
13597 }
13598
13599
13600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13601   void * jresult ;
13602   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13603   Dali::Matrix *arg2 = 0 ;
13604   Dali::Matrix3 *result = 0 ;
13605
13606   arg1 = (Dali::Matrix3 *)jarg1;
13607   arg2 = (Dali::Matrix *)jarg2;
13608   if (!arg2) {
13609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13610     return 0;
13611   }
13612   {
13613     try {
13614       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13615     } catch (std::out_of_range& e) {
13616       {
13617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13618       };
13619     } catch (std::exception& e) {
13620       {
13621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13622       };
13623     } catch (Dali::DaliException e) {
13624       {
13625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13626       };
13627     } catch (...) {
13628       {
13629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13630       };
13631     }
13632   }
13633
13634   jresult = (void *)result;
13635   return jresult;
13636 }
13637
13638
13639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13640   unsigned int jresult ;
13641   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13642   Dali::Matrix3 *arg2 = 0 ;
13643   bool result;
13644
13645   arg1 = (Dali::Matrix3 *)jarg1;
13646   arg2 = (Dali::Matrix3 *)jarg2;
13647   if (!arg2) {
13648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13649     return 0;
13650   }
13651   {
13652     try {
13653       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13654     } catch (std::out_of_range& e) {
13655       {
13656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13657       };
13658     } catch (std::exception& e) {
13659       {
13660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13661       };
13662     } catch (Dali::DaliException e) {
13663       {
13664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13665       };
13666     } catch (...) {
13667       {
13668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13669       };
13670     }
13671   }
13672
13673   jresult = result;
13674   return jresult;
13675 }
13676
13677
13678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13679   unsigned int jresult ;
13680   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13681   Dali::Matrix3 *arg2 = 0 ;
13682   bool result;
13683
13684   arg1 = (Dali::Matrix3 *)jarg1;
13685   arg2 = (Dali::Matrix3 *)jarg2;
13686   if (!arg2) {
13687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13688     return 0;
13689   }
13690   {
13691     try {
13692       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13693     } catch (std::out_of_range& e) {
13694       {
13695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13696       };
13697     } catch (std::exception& e) {
13698       {
13699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13700       };
13701     } catch (Dali::DaliException e) {
13702       {
13703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13704       };
13705     } catch (...) {
13706       {
13707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13708       };
13709     }
13710   }
13711
13712   jresult = result;
13713   return jresult;
13714 }
13715
13716
13717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13718   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13719
13720   arg1 = (Dali::Matrix3 *)jarg1;
13721   {
13722     try {
13723       delete arg1;
13724     } catch (std::out_of_range& e) {
13725       {
13726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13727       };
13728     } catch (std::exception& e) {
13729       {
13730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13731       };
13732     } catch (Dali::DaliException e) {
13733       {
13734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13735       };
13736     } catch (...) {
13737       {
13738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13739       };
13740     }
13741   }
13742
13743 }
13744
13745
13746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13747   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13748
13749   arg1 = (Dali::Matrix3 *)jarg1;
13750   {
13751     try {
13752       (arg1)->SetIdentity();
13753     } catch (std::out_of_range& e) {
13754       {
13755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13756       };
13757     } catch (std::exception& e) {
13758       {
13759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13760       };
13761     } catch (Dali::DaliException e) {
13762       {
13763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13764       };
13765     } catch (...) {
13766       {
13767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13768       };
13769     }
13770   }
13771
13772 }
13773
13774
13775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13776   void * jresult ;
13777   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13778   float *result = 0 ;
13779
13780   arg1 = (Dali::Matrix3 *)jarg1;
13781   {
13782     try {
13783       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (Dali::DaliException e) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13795       };
13796     } catch (...) {
13797       {
13798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13799       };
13800     }
13801   }
13802
13803   jresult = (void *)result;
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13809   unsigned int jresult ;
13810   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13811   bool result;
13812
13813   arg1 = (Dali::Matrix3 *)jarg1;
13814   {
13815     try {
13816       result = (bool)(arg1)->Invert();
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (Dali::DaliException e) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13828       };
13829     } catch (...) {
13830       {
13831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13832       };
13833     }
13834   }
13835
13836   jresult = result;
13837   return jresult;
13838 }
13839
13840
13841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13842   unsigned int jresult ;
13843   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13844   bool result;
13845
13846   arg1 = (Dali::Matrix3 *)jarg1;
13847   {
13848     try {
13849       result = (bool)(arg1)->Transpose();
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13857       };
13858     } catch (Dali::DaliException e) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13861       };
13862     } catch (...) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13865       };
13866     }
13867   }
13868
13869   jresult = result;
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13875   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13876   float arg2 ;
13877
13878   arg1 = (Dali::Matrix3 *)jarg1;
13879   arg2 = (float)jarg2;
13880   {
13881     try {
13882       (arg1)->Scale(arg2);
13883     } catch (std::out_of_range& e) {
13884       {
13885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13886       };
13887     } catch (std::exception& e) {
13888       {
13889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13890       };
13891     } catch (Dali::DaliException e) {
13892       {
13893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13894       };
13895     } catch (...) {
13896       {
13897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13898       };
13899     }
13900   }
13901
13902 }
13903
13904
13905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13906   float jresult ;
13907   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13908   float result;
13909
13910   arg1 = (Dali::Matrix3 *)jarg1;
13911   {
13912     try {
13913       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13914     } catch (std::out_of_range& e) {
13915       {
13916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13917       };
13918     } catch (std::exception& e) {
13919       {
13920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (Dali::DaliException e) {
13923       {
13924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13939   unsigned int jresult ;
13940   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13941   bool result;
13942
13943   arg1 = (Dali::Matrix3 *)jarg1;
13944   {
13945     try {
13946       result = (bool)(arg1)->ScaledInverseTranspose();
13947     } catch (std::out_of_range& e) {
13948       {
13949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13950       };
13951     } catch (std::exception& e) {
13952       {
13953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13954       };
13955     } catch (Dali::DaliException e) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13962       };
13963     }
13964   }
13965
13966   jresult = result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13972   Dali::Matrix3 *arg1 = 0 ;
13973   Dali::Matrix3 *arg2 = 0 ;
13974   Dali::Matrix3 *arg3 = 0 ;
13975
13976   arg1 = (Dali::Matrix3 *)jarg1;
13977   if (!arg1) {
13978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13979     return ;
13980   }
13981   arg2 = (Dali::Matrix3 *)jarg2;
13982   if (!arg2) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13984     return ;
13985   }
13986   arg3 = (Dali::Matrix3 *)jarg3;
13987   if (!arg3) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13989     return ;
13990   }
13991   {
13992     try {
13993       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13994     } catch (std::out_of_range& e) {
13995       {
13996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13997       };
13998     } catch (std::exception& e) {
13999       {
14000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14001       };
14002     } catch (Dali::DaliException e) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14005       };
14006     } catch (...) {
14007       {
14008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14009       };
14010     }
14011   }
14012
14013 }
14014
14015
14016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14017   float jresult ;
14018   float arg1 ;
14019   float arg2 ;
14020   float result;
14021
14022   arg1 = (float)jarg1;
14023   arg2 = (float)jarg2;
14024   {
14025     try {
14026       result = (float)Dali::Random::Range(arg1,arg2);
14027     } catch (std::out_of_range& e) {
14028       {
14029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14030       };
14031     } catch (std::exception& e) {
14032       {
14033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14034       };
14035     } catch (Dali::DaliException e) {
14036       {
14037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14038       };
14039     } catch (...) {
14040       {
14041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14042       };
14043     }
14044   }
14045
14046   jresult = result;
14047   return jresult;
14048 }
14049
14050
14051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14052   void * jresult ;
14053   Dali::Vector4 result;
14054
14055   {
14056     try {
14057       result = Dali::Random::Axis();
14058     } catch (std::out_of_range& e) {
14059       {
14060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14061       };
14062     } catch (std::exception& e) {
14063       {
14064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14065       };
14066     } catch (Dali::DaliException e) {
14067       {
14068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14069       };
14070     } catch (...) {
14071       {
14072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14073       };
14074     }
14075   }
14076
14077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14078   return jresult;
14079 }
14080
14081
14082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14083   void * jresult ;
14084   Dali::AngleAxis *result = 0 ;
14085
14086   {
14087     try {
14088       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14089     } catch (std::out_of_range& e) {
14090       {
14091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14092       };
14093     } catch (std::exception& e) {
14094       {
14095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14096       };
14097     } catch (Dali::DaliException e) {
14098       {
14099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14100       };
14101     } catch (...) {
14102       {
14103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14104       };
14105     }
14106   }
14107
14108   jresult = (void *)result;
14109   return jresult;
14110 }
14111
14112
14113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14114   void * jresult ;
14115   Dali::Radian arg1 ;
14116   Dali::Vector3 *arg2 = 0 ;
14117   Dali::Radian *argp1 ;
14118   Dali::AngleAxis *result = 0 ;
14119
14120   argp1 = (Dali::Radian *)jarg1;
14121   if (!argp1) {
14122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14123     return 0;
14124   }
14125   arg1 = *argp1;
14126   arg2 = (Dali::Vector3 *)jarg2;
14127   if (!arg2) {
14128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14129     return 0;
14130   }
14131   {
14132     try {
14133       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14141       };
14142     } catch (Dali::DaliException e) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14145       };
14146     } catch (...) {
14147       {
14148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14149       };
14150     }
14151   }
14152
14153   jresult = (void *)result;
14154   return jresult;
14155 }
14156
14157
14158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14159   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14160   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14161
14162   arg1 = (Dali::AngleAxis *)jarg1;
14163   arg2 = (Dali::Radian *)jarg2;
14164   if (arg1) (arg1)->angle = *arg2;
14165 }
14166
14167
14168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14169   void * jresult ;
14170   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14171   Dali::Radian *result = 0 ;
14172
14173   arg1 = (Dali::AngleAxis *)jarg1;
14174   result = (Dali::Radian *)& ((arg1)->angle);
14175   jresult = (void *)result;
14176   return jresult;
14177 }
14178
14179
14180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14181   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14182   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14183
14184   arg1 = (Dali::AngleAxis *)jarg1;
14185   arg2 = (Dali::Vector3 *)jarg2;
14186   if (arg1) (arg1)->axis = *arg2;
14187 }
14188
14189
14190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14191   void * jresult ;
14192   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14193   Dali::Vector3 *result = 0 ;
14194
14195   arg1 = (Dali::AngleAxis *)jarg1;
14196   result = (Dali::Vector3 *)& ((arg1)->axis);
14197   jresult = (void *)result;
14198   return jresult;
14199 }
14200
14201
14202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14203   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14204
14205   arg1 = (Dali::AngleAxis *)jarg1;
14206   {
14207     try {
14208       delete arg1;
14209     } catch (std::out_of_range& e) {
14210       {
14211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14212       };
14213     } catch (std::exception& e) {
14214       {
14215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14216       };
14217     } catch (Dali::DaliException e) {
14218       {
14219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14220       };
14221     } catch (...) {
14222       {
14223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14224       };
14225     }
14226   }
14227
14228 }
14229
14230
14231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14232   unsigned int jresult ;
14233   Dali::AngleAxis *arg1 = 0 ;
14234   Dali::AngleAxis *arg2 = 0 ;
14235   bool result;
14236
14237   arg1 = (Dali::AngleAxis *)jarg1;
14238   if (!arg1) {
14239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14240     return 0;
14241   }
14242   arg2 = (Dali::AngleAxis *)jarg2;
14243   if (!arg2) {
14244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14245     return 0;
14246   }
14247   {
14248     try {
14249       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14250     } catch (std::out_of_range& e) {
14251       {
14252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (std::exception& e) {
14255       {
14256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14257       };
14258     } catch (Dali::DaliException e) {
14259       {
14260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14261       };
14262     } catch (...) {
14263       {
14264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14265       };
14266     }
14267   }
14268
14269   jresult = result;
14270   return jresult;
14271 }
14272
14273
14274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14275   unsigned int jresult ;
14276   unsigned int arg1 ;
14277   unsigned int result;
14278
14279   arg1 = (unsigned int)jarg1;
14280   {
14281     try {
14282       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14283     } catch (std::out_of_range& e) {
14284       {
14285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (std::exception& e) {
14288       {
14289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14290       };
14291     } catch (Dali::DaliException e) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14294       };
14295     } catch (...) {
14296       {
14297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14298       };
14299     }
14300   }
14301
14302   jresult = result;
14303   return jresult;
14304 }
14305
14306
14307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14308   unsigned int jresult ;
14309   unsigned int arg1 ;
14310   bool result;
14311
14312   arg1 = (unsigned int)jarg1;
14313   {
14314     try {
14315       result = (bool)Dali::IsPowerOfTwo(arg1);
14316     } catch (std::out_of_range& e) {
14317       {
14318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14319       };
14320     } catch (std::exception& e) {
14321       {
14322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14323       };
14324     } catch (Dali::DaliException e) {
14325       {
14326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14327       };
14328     } catch (...) {
14329       {
14330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14331       };
14332     }
14333   }
14334
14335   jresult = result;
14336   return jresult;
14337 }
14338
14339
14340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14341   float jresult ;
14342   float arg1 ;
14343   float arg2 ;
14344   float result;
14345
14346   arg1 = (float)jarg1;
14347   arg2 = (float)jarg2;
14348   {
14349     try {
14350       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14351     } catch (std::out_of_range& e) {
14352       {
14353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (std::exception& e) {
14356       {
14357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (Dali::DaliException e) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369
14370   jresult = result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14376   unsigned int jresult ;
14377   float arg1 ;
14378   bool result;
14379
14380   arg1 = (float)jarg1;
14381   {
14382     try {
14383       result = (bool)Dali::EqualsZero(arg1);
14384     } catch (std::out_of_range& e) {
14385       {
14386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14387       };
14388     } catch (std::exception& e) {
14389       {
14390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (Dali::DaliException e) {
14393       {
14394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14395       };
14396     } catch (...) {
14397       {
14398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14399       };
14400     }
14401   }
14402
14403   jresult = result;
14404   return jresult;
14405 }
14406
14407
14408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14409   unsigned int jresult ;
14410   float arg1 ;
14411   float arg2 ;
14412   bool result;
14413
14414   arg1 = (float)jarg1;
14415   arg2 = (float)jarg2;
14416   {
14417     try {
14418       result = (bool)Dali::Equals(arg1,arg2);
14419     } catch (std::out_of_range& e) {
14420       {
14421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (std::exception& e) {
14424       {
14425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14426       };
14427     } catch (Dali::DaliException e) {
14428       {
14429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14430       };
14431     } catch (...) {
14432       {
14433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14434       };
14435     }
14436   }
14437
14438   jresult = result;
14439   return jresult;
14440 }
14441
14442
14443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14444   unsigned int jresult ;
14445   float arg1 ;
14446   float arg2 ;
14447   float arg3 ;
14448   bool result;
14449
14450   arg1 = (float)jarg1;
14451   arg2 = (float)jarg2;
14452   arg3 = (float)jarg3;
14453   {
14454     try {
14455       result = (bool)Dali::Equals(arg1,arg2,arg3);
14456     } catch (std::out_of_range& e) {
14457       {
14458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (std::exception& e) {
14461       {
14462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14463       };
14464     } catch (Dali::DaliException e) {
14465       {
14466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14467       };
14468     } catch (...) {
14469       {
14470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14471       };
14472     }
14473   }
14474
14475   jresult = result;
14476   return jresult;
14477 }
14478
14479
14480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14481   float jresult ;
14482   float arg1 ;
14483   int arg2 ;
14484   float result;
14485
14486   arg1 = (float)jarg1;
14487   arg2 = (int)jarg2;
14488   {
14489     try {
14490       result = (float)Dali::Round(arg1,arg2);
14491     } catch (std::out_of_range& e) {
14492       {
14493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14494       };
14495     } catch (std::exception& e) {
14496       {
14497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (Dali::DaliException e) {
14500       {
14501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14502       };
14503     } catch (...) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14506       };
14507     }
14508   }
14509
14510   jresult = result;
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14516   float jresult ;
14517   float arg1 ;
14518   float arg2 ;
14519   float arg3 ;
14520   float result;
14521
14522   arg1 = (float)jarg1;
14523   arg2 = (float)jarg2;
14524   arg3 = (float)jarg3;
14525   {
14526     try {
14527       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14528     } catch (std::out_of_range& e) {
14529       {
14530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14531       };
14532     } catch (std::exception& e) {
14533       {
14534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14535       };
14536     } catch (Dali::DaliException e) {
14537       {
14538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14539       };
14540     } catch (...) {
14541       {
14542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14543       };
14544     }
14545   }
14546
14547   jresult = result;
14548   return jresult;
14549 }
14550
14551
14552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14553   float jresult ;
14554   float arg1 ;
14555   float arg2 ;
14556   float arg3 ;
14557   float arg4 ;
14558   float result;
14559
14560   arg1 = (float)jarg1;
14561   arg2 = (float)jarg2;
14562   arg3 = (float)jarg3;
14563   arg4 = (float)jarg4;
14564   {
14565     try {
14566       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14567     } catch (std::out_of_range& e) {
14568       {
14569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14570       };
14571     } catch (std::exception& e) {
14572       {
14573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14574       };
14575     } catch (Dali::DaliException e) {
14576       {
14577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14578       };
14579     } catch (...) {
14580       {
14581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14582       };
14583     }
14584   }
14585
14586   jresult = result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14592   int jresult ;
14593   int result;
14594
14595   result = (int)(int)Dali::Property::INVALID_INDEX;
14596   jresult = result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14602   int jresult ;
14603   int result;
14604
14605   result = (int)(int)Dali::Property::INVALID_KEY;
14606   jresult = result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14612   int jresult ;
14613   int result;
14614
14615   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14616   jresult = result;
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14622   void * jresult ;
14623   Dali::Handle *arg1 = 0 ;
14624   Dali::Property::Index arg2 ;
14625   Dali::Property *result = 0 ;
14626
14627   arg1 = (Dali::Handle *)jarg1;
14628   if (!arg1) {
14629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14630     return 0;
14631   }
14632   arg2 = (Dali::Property::Index)jarg2;
14633   {
14634     try {
14635       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14643       };
14644     } catch (Dali::DaliException e) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14647       };
14648     } catch (...) {
14649       {
14650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14651       };
14652     }
14653   }
14654
14655   jresult = (void *)result;
14656   return jresult;
14657 }
14658
14659
14660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14661   void * jresult ;
14662   Dali::Handle *arg1 = 0 ;
14663   Dali::Property::Index arg2 ;
14664   int arg3 ;
14665   Dali::Property *result = 0 ;
14666
14667   arg1 = (Dali::Handle *)jarg1;
14668   if (!arg1) {
14669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14670     return 0;
14671   }
14672   arg2 = (Dali::Property::Index)jarg2;
14673   arg3 = (int)jarg3;
14674   {
14675     try {
14676       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14677     } catch (std::out_of_range& e) {
14678       {
14679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14680       };
14681     } catch (std::exception& e) {
14682       {
14683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14684       };
14685     } catch (Dali::DaliException e) {
14686       {
14687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14688       };
14689     } catch (...) {
14690       {
14691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14692       };
14693     }
14694   }
14695
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14702   void * jresult ;
14703   Dali::Handle *arg1 = 0 ;
14704   std::string *arg2 = 0 ;
14705   Dali::Property *result = 0 ;
14706
14707   arg1 = (Dali::Handle *)jarg1;
14708   if (!arg1) {
14709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14710     return 0;
14711   }
14712   if (!jarg2) {
14713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14714     return 0;
14715   }
14716   std::string arg2_str(jarg2);
14717   arg2 = &arg2_str;
14718   {
14719     try {
14720       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14721     } catch (std::out_of_range& e) {
14722       {
14723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (std::exception& e) {
14726       {
14727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14728       };
14729     } catch (Dali::DaliException e) {
14730       {
14731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14732       };
14733     } catch (...) {
14734       {
14735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14736       };
14737     }
14738   }
14739
14740   jresult = (void *)result;
14741
14742   //argout typemap for const std::string&
14743
14744   return jresult;
14745 }
14746
14747
14748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14749   void * jresult ;
14750   Dali::Handle *arg1 = 0 ;
14751   std::string *arg2 = 0 ;
14752   int arg3 ;
14753   Dali::Property *result = 0 ;
14754
14755   arg1 = (Dali::Handle *)jarg1;
14756   if (!arg1) {
14757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14758     return 0;
14759   }
14760   if (!jarg2) {
14761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14762     return 0;
14763   }
14764   std::string arg2_str(jarg2);
14765   arg2 = &arg2_str;
14766   arg3 = (int)jarg3;
14767   {
14768     try {
14769       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14770     } catch (std::out_of_range& e) {
14771       {
14772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (std::exception& e) {
14775       {
14776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14777       };
14778     } catch (Dali::DaliException e) {
14779       {
14780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14781       };
14782     } catch (...) {
14783       {
14784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14785       };
14786     }
14787   }
14788
14789   jresult = (void *)result;
14790
14791   //argout typemap for const std::string&
14792
14793   return jresult;
14794 }
14795
14796
14797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14798   Dali::Property *arg1 = (Dali::Property *) 0 ;
14799
14800   arg1 = (Dali::Property *)jarg1;
14801   {
14802     try {
14803       delete arg1;
14804     } catch (std::out_of_range& e) {
14805       {
14806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14807       };
14808     } catch (std::exception& e) {
14809       {
14810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14811       };
14812     } catch (Dali::DaliException e) {
14813       {
14814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14815       };
14816     } catch (...) {
14817       {
14818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14819       };
14820     }
14821   }
14822
14823 }
14824
14825
14826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14827   Dali::Property *arg1 = (Dali::Property *) 0 ;
14828   Dali::Handle *arg2 = 0 ;
14829
14830   arg1 = (Dali::Property *)jarg1;
14831   arg2 = (Dali::Handle *)jarg2;
14832   if (!arg2) {
14833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14834     return ;
14835   }
14836   if (arg1) (arg1)->object = *arg2;
14837 }
14838
14839
14840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14841   void * jresult ;
14842   Dali::Property *arg1 = (Dali::Property *) 0 ;
14843   Dali::Handle *result = 0 ;
14844
14845   arg1 = (Dali::Property *)jarg1;
14846   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14847   jresult = (void *)result;
14848   return jresult;
14849 }
14850
14851
14852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14853   Dali::Property *arg1 = (Dali::Property *) 0 ;
14854   Dali::Property::Index arg2 ;
14855
14856   arg1 = (Dali::Property *)jarg1;
14857   arg2 = (Dali::Property::Index)jarg2;
14858   if (arg1) (arg1)->propertyIndex = arg2;
14859 }
14860
14861
14862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14863   int jresult ;
14864   Dali::Property *arg1 = (Dali::Property *) 0 ;
14865   Dali::Property::Index result;
14866
14867   arg1 = (Dali::Property *)jarg1;
14868   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14869   jresult = result;
14870   return jresult;
14871 }
14872
14873
14874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14875   Dali::Property *arg1 = (Dali::Property *) 0 ;
14876   int arg2 ;
14877
14878   arg1 = (Dali::Property *)jarg1;
14879   arg2 = (int)jarg2;
14880   if (arg1) (arg1)->componentIndex = arg2;
14881 }
14882
14883
14884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14885   int jresult ;
14886   Dali::Property *arg1 = (Dali::Property *) 0 ;
14887   int result;
14888
14889   arg1 = (Dali::Property *)jarg1;
14890   result = (int) ((arg1)->componentIndex);
14891   jresult = result;
14892   return jresult;
14893 }
14894
14895
14896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14897   void * jresult ;
14898   Dali::Property::Array *result = 0 ;
14899
14900   {
14901     try {
14902       result = (Dali::Property::Array *)new Dali::Property::Array();
14903     } catch (std::out_of_range& e) {
14904       {
14905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14906       };
14907     } catch (std::exception& e) {
14908       {
14909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (Dali::DaliException e) {
14912       {
14913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14914       };
14915     } catch (...) {
14916       {
14917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14918       };
14919     }
14920   }
14921
14922   jresult = (void *)result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14928   void * jresult ;
14929   Dali::Property::Array *arg1 = 0 ;
14930   Dali::Property::Array *result = 0 ;
14931
14932   arg1 = (Dali::Property::Array *)jarg1;
14933   if (!arg1) {
14934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14935     return 0;
14936   }
14937   {
14938     try {
14939       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14940     } catch (std::out_of_range& e) {
14941       {
14942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (std::exception& e) {
14945       {
14946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14947       };
14948     } catch (Dali::DaliException e) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14951       };
14952     } catch (...) {
14953       {
14954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14955       };
14956     }
14957   }
14958
14959   jresult = (void *)result;
14960   return jresult;
14961 }
14962
14963
14964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14965   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14966
14967   arg1 = (Dali::Property::Array *)jarg1;
14968   {
14969     try {
14970       delete arg1;
14971     } catch (std::out_of_range& e) {
14972       {
14973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14974       };
14975     } catch (std::exception& e) {
14976       {
14977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14978       };
14979     } catch (Dali::DaliException e) {
14980       {
14981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14982       };
14983     } catch (...) {
14984       {
14985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14986       };
14987     }
14988   }
14989
14990 }
14991
14992
14993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14994   unsigned long jresult ;
14995   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14996   Dali::Property::Array::SizeType result;
14997
14998   arg1 = (Dali::Property::Array *)jarg1;
14999   {
15000     try {
15001       result = ((Dali::Property::Array const *)arg1)->Size();
15002     } catch (std::out_of_range& e) {
15003       {
15004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (std::exception& e) {
15007       {
15008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (Dali::DaliException e) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15013       };
15014     } catch (...) {
15015       {
15016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15017       };
15018     }
15019   }
15020
15021   jresult = (unsigned long)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15027   unsigned long jresult ;
15028   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15029   Dali::Property::Array::SizeType result;
15030
15031   arg1 = (Dali::Property::Array *)jarg1;
15032   {
15033     try {
15034       result = ((Dali::Property::Array const *)arg1)->Count();
15035     } catch (std::out_of_range& e) {
15036       {
15037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (std::exception& e) {
15040       {
15041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (Dali::DaliException e) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15046       };
15047     } catch (...) {
15048       {
15049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15050       };
15051     }
15052   }
15053
15054   jresult = (unsigned long)result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15060   unsigned int jresult ;
15061   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15062   bool result;
15063
15064   arg1 = (Dali::Property::Array *)jarg1;
15065   {
15066     try {
15067       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15068     } catch (std::out_of_range& e) {
15069       {
15070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (std::exception& e) {
15073       {
15074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15075       };
15076     } catch (Dali::DaliException e) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15079       };
15080     } catch (...) {
15081       {
15082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15083       };
15084     }
15085   }
15086
15087   jresult = result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15093   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15094
15095   arg1 = (Dali::Property::Array *)jarg1;
15096   {
15097     try {
15098       (arg1)->Clear();
15099     } catch (std::out_of_range& e) {
15100       {
15101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15102       };
15103     } catch (std::exception& e) {
15104       {
15105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15106       };
15107     } catch (Dali::DaliException e) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15110       };
15111     } catch (...) {
15112       {
15113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15114       };
15115     }
15116   }
15117
15118 }
15119
15120
15121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15122   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15123   Dali::Property::Array::SizeType arg2 ;
15124
15125   arg1 = (Dali::Property::Array *)jarg1;
15126   arg2 = (Dali::Property::Array::SizeType)jarg2;
15127   {
15128     try {
15129       (arg1)->Reserve(arg2);
15130     } catch (std::out_of_range& e) {
15131       {
15132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15133       };
15134     } catch (std::exception& e) {
15135       {
15136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15137       };
15138     } catch (Dali::DaliException e) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15141       };
15142     } catch (...) {
15143       {
15144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15145       };
15146     }
15147   }
15148
15149 }
15150
15151
15152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15153   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15154   Dali::Property::Array::SizeType arg2 ;
15155
15156   arg1 = (Dali::Property::Array *)jarg1;
15157   arg2 = (Dali::Property::Array::SizeType)jarg2;
15158   {
15159     try {
15160       (arg1)->Resize(arg2);
15161     } catch (std::out_of_range& e) {
15162       {
15163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15164       };
15165     } catch (std::exception& e) {
15166       {
15167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15168       };
15169     } catch (Dali::DaliException e) {
15170       {
15171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15176       };
15177     }
15178   }
15179
15180 }
15181
15182
15183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15184   unsigned long jresult ;
15185   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15186   Dali::Property::Array::SizeType result;
15187
15188   arg1 = (Dali::Property::Array *)jarg1;
15189   {
15190     try {
15191       result = (arg1)->Capacity();
15192     } catch (std::out_of_range& e) {
15193       {
15194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15195       };
15196     } catch (std::exception& e) {
15197       {
15198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15199       };
15200     } catch (Dali::DaliException e) {
15201       {
15202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15203       };
15204     } catch (...) {
15205       {
15206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15207       };
15208     }
15209   }
15210
15211   jresult = (unsigned long)result;
15212   return jresult;
15213 }
15214
15215
15216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15217   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15218   Dali::Property::Value *arg2 = 0 ;
15219
15220   arg1 = (Dali::Property::Array *)jarg1;
15221   arg2 = (Dali::Property::Value *)jarg2;
15222   if (!arg2) {
15223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15224     return ;
15225   }
15226   {
15227     try {
15228       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15229     } catch (std::out_of_range& e) {
15230       {
15231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15232       };
15233     } catch (std::exception& e) {
15234       {
15235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15236       };
15237     } catch (Dali::DaliException e) {
15238       {
15239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15240       };
15241     } catch (...) {
15242       {
15243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15244       };
15245     }
15246   }
15247
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15252   void * jresult ;
15253   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15254   Dali::Property::Value *arg2 = 0 ;
15255   Dali::Property::Array *result = 0 ;
15256
15257   arg1 = (Dali::Property::Array *)jarg1;
15258   arg2 = (Dali::Property::Value *)jarg2;
15259   if (!arg2) {
15260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15261     return 0;
15262   }
15263   {
15264     try {
15265       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15266     } catch (std::out_of_range& e) {
15267       {
15268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15269       };
15270     } catch (std::exception& e) {
15271       {
15272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15273       };
15274     } catch (Dali::DaliException e) {
15275       {
15276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15277       };
15278     } catch (...) {
15279       {
15280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15281       };
15282     }
15283   }
15284
15285   jresult = (void *)result;
15286   return jresult;
15287 }
15288
15289
15290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15291   void * jresult ;
15292   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15293   Dali::Property::Array::SizeType arg2 ;
15294   Dali::Property::Value *result = 0 ;
15295
15296   arg1 = (Dali::Property::Array *)jarg1;
15297   arg2 = (Dali::Property::Array::SizeType)jarg2;
15298   {
15299     try {
15300       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15301     } catch (std::out_of_range& e) {
15302       {
15303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15304       };
15305     } catch (std::exception& e) {
15306       {
15307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15308       };
15309     } catch (Dali::DaliException e) {
15310       {
15311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15312       };
15313     } catch (...) {
15314       {
15315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15316       };
15317     }
15318   }
15319
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15326   void * jresult ;
15327   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15328   Dali::Property::Array::SizeType arg2 ;
15329   Dali::Property::Value *result = 0 ;
15330
15331   arg1 = (Dali::Property::Array *)jarg1;
15332   arg2 = (Dali::Property::Array::SizeType)jarg2;
15333   {
15334     try {
15335       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15336     } catch (std::out_of_range& e) {
15337       {
15338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15339       };
15340     } catch (std::exception& e) {
15341       {
15342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15343       };
15344     } catch (Dali::DaliException e) {
15345       {
15346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15347       };
15348     } catch (...) {
15349       {
15350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15351       };
15352     }
15353   }
15354
15355   jresult = (void *)result;
15356   return jresult;
15357 }
15358
15359
15360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15361   void * jresult ;
15362   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15363   Dali::Property::Array *arg2 = 0 ;
15364   Dali::Property::Array *result = 0 ;
15365
15366   arg1 = (Dali::Property::Array *)jarg1;
15367   arg2 = (Dali::Property::Array *)jarg2;
15368   if (!arg2) {
15369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15370     return 0;
15371   }
15372   {
15373     try {
15374       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15375     } catch (std::out_of_range& e) {
15376       {
15377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15378       };
15379     } catch (std::exception& e) {
15380       {
15381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15382       };
15383     } catch (Dali::DaliException e) {
15384       {
15385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15386       };
15387     } catch (...) {
15388       {
15389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15390       };
15391     }
15392   }
15393
15394   jresult = (void *)result;
15395   return jresult;
15396 }
15397
15398
15399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15400   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15401   enum Dali::Property::Key::Type arg2 ;
15402
15403   arg1 = (Dali::Property::Key *)jarg1;
15404   arg2 = (enum Dali::Property::Key::Type)jarg2;
15405   if (arg1) (arg1)->type = arg2;
15406 }
15407
15408
15409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15410   int jresult ;
15411   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15412   enum Dali::Property::Key::Type result;
15413
15414   arg1 = (Dali::Property::Key *)jarg1;
15415   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15416   jresult = (int)result;
15417   return jresult;
15418 }
15419
15420
15421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15422   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15423   Dali::Property::Index arg2 ;
15424
15425   arg1 = (Dali::Property::Key *)jarg1;
15426   arg2 = (Dali::Property::Index)jarg2;
15427   if (arg1) (arg1)->indexKey = arg2;
15428 }
15429
15430
15431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15432   int jresult ;
15433   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15434   Dali::Property::Index result;
15435
15436   arg1 = (Dali::Property::Key *)jarg1;
15437   result = (Dali::Property::Index) ((arg1)->indexKey);
15438   jresult = result;
15439   return jresult;
15440 }
15441
15442
15443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15444   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15445   std::string *arg2 = 0 ;
15446
15447   arg1 = (Dali::Property::Key *)jarg1;
15448   if (!jarg2) {
15449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15450     return ;
15451   }
15452   std::string arg2_str(jarg2);
15453   arg2 = &arg2_str;
15454   if (arg1) (arg1)->stringKey = *arg2;
15455
15456   //argout typemap for const std::string&
15457
15458 }
15459
15460
15461 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15462   char * jresult ;
15463   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15464   std::string *result = 0 ;
15465
15466   arg1 = (Dali::Property::Key *)jarg1;
15467   result = (std::string *) & ((arg1)->stringKey);
15468   jresult = SWIG_csharp_string_callback(result->c_str());
15469   return jresult;
15470 }
15471
15472
15473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15474   void * jresult ;
15475   std::string *arg1 = 0 ;
15476   Dali::Property::Key *result = 0 ;
15477
15478   if (!jarg1) {
15479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15480     return 0;
15481   }
15482   std::string arg1_str(jarg1);
15483   arg1 = &arg1_str;
15484   {
15485     try {
15486       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15487     } catch (std::out_of_range& e) {
15488       {
15489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15490       };
15491     } catch (std::exception& e) {
15492       {
15493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15494       };
15495     } catch (Dali::DaliException e) {
15496       {
15497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15498       };
15499     } catch (...) {
15500       {
15501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15502       };
15503     }
15504   }
15505
15506   jresult = (void *)result;
15507
15508   //argout typemap for const std::string&
15509
15510   return jresult;
15511 }
15512
15513
15514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15515   void * jresult ;
15516   Dali::Property::Index arg1 ;
15517   Dali::Property::Key *result = 0 ;
15518
15519   arg1 = (Dali::Property::Index)jarg1;
15520   {
15521     try {
15522       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15523     } catch (std::out_of_range& e) {
15524       {
15525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15526       };
15527     } catch (std::exception& e) {
15528       {
15529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15530       };
15531     } catch (Dali::DaliException e) {
15532       {
15533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15534       };
15535     } catch (...) {
15536       {
15537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15538       };
15539     }
15540   }
15541
15542   jresult = (void *)result;
15543   return jresult;
15544 }
15545
15546
15547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15548   unsigned int jresult ;
15549   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15550   std::string *arg2 = 0 ;
15551   bool result;
15552
15553   arg1 = (Dali::Property::Key *)jarg1;
15554   if (!jarg2) {
15555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15556     return 0;
15557   }
15558   std::string arg2_str(jarg2);
15559   arg2 = &arg2_str;
15560   {
15561     try {
15562       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15563     } catch (std::out_of_range& e) {
15564       {
15565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15566       };
15567     } catch (std::exception& e) {
15568       {
15569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15570       };
15571     } catch (Dali::DaliException e) {
15572       {
15573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15574       };
15575     } catch (...) {
15576       {
15577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15578       };
15579     }
15580   }
15581
15582   jresult = result;
15583
15584   //argout typemap for const std::string&
15585
15586   return jresult;
15587 }
15588
15589
15590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15591   unsigned int jresult ;
15592   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15593   Dali::Property::Index arg2 ;
15594   bool result;
15595
15596   arg1 = (Dali::Property::Key *)jarg1;
15597   arg2 = (Dali::Property::Index)jarg2;
15598   {
15599     try {
15600       result = (bool)(arg1)->operator ==(arg2);
15601     } catch (std::out_of_range& e) {
15602       {
15603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15604       };
15605     } catch (std::exception& e) {
15606       {
15607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15608       };
15609     } catch (Dali::DaliException e) {
15610       {
15611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15612       };
15613     } catch (...) {
15614       {
15615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15616       };
15617     }
15618   }
15619
15620   jresult = result;
15621   return jresult;
15622 }
15623
15624
15625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15626   unsigned int jresult ;
15627   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15628   Dali::Property::Key *arg2 = 0 ;
15629   bool result;
15630
15631   arg1 = (Dali::Property::Key *)jarg1;
15632   arg2 = (Dali::Property::Key *)jarg2;
15633   if (!arg2) {
15634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15635     return 0;
15636   }
15637   {
15638     try {
15639       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15640     } catch (std::out_of_range& e) {
15641       {
15642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (std::exception& e) {
15645       {
15646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15647       };
15648     } catch (Dali::DaliException e) {
15649       {
15650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15651       };
15652     } catch (...) {
15653       {
15654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15655       };
15656     }
15657   }
15658
15659   jresult = result;
15660   return jresult;
15661 }
15662
15663
15664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15665   unsigned int jresult ;
15666   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15667   std::string *arg2 = 0 ;
15668   bool result;
15669
15670   arg1 = (Dali::Property::Key *)jarg1;
15671   if (!jarg2) {
15672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15673     return 0;
15674   }
15675   std::string arg2_str(jarg2);
15676   arg2 = &arg2_str;
15677   {
15678     try {
15679       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15680     } catch (std::out_of_range& e) {
15681       {
15682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15683       };
15684     } catch (std::exception& e) {
15685       {
15686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15687       };
15688     } catch (Dali::DaliException e) {
15689       {
15690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15691       };
15692     } catch (...) {
15693       {
15694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15695       };
15696     }
15697   }
15698
15699   jresult = result;
15700
15701   //argout typemap for const std::string&
15702
15703   return jresult;
15704 }
15705
15706
15707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15708   unsigned int jresult ;
15709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15710   Dali::Property::Index arg2 ;
15711   bool result;
15712
15713   arg1 = (Dali::Property::Key *)jarg1;
15714   arg2 = (Dali::Property::Index)jarg2;
15715   {
15716     try {
15717       result = (bool)(arg1)->operator !=(arg2);
15718     } catch (std::out_of_range& e) {
15719       {
15720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15721       };
15722     } catch (std::exception& e) {
15723       {
15724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15725       };
15726     } catch (Dali::DaliException e) {
15727       {
15728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15729       };
15730     } catch (...) {
15731       {
15732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15733       };
15734     }
15735   }
15736
15737   jresult = result;
15738   return jresult;
15739 }
15740
15741
15742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15743   unsigned int jresult ;
15744   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15745   Dali::Property::Key *arg2 = 0 ;
15746   bool result;
15747
15748   arg1 = (Dali::Property::Key *)jarg1;
15749   arg2 = (Dali::Property::Key *)jarg2;
15750   if (!arg2) {
15751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15752     return 0;
15753   }
15754   {
15755     try {
15756       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15757     } catch (std::out_of_range& e) {
15758       {
15759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15760       };
15761     } catch (std::exception& e) {
15762       {
15763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15764       };
15765     } catch (Dali::DaliException e) {
15766       {
15767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15768       };
15769     } catch (...) {
15770       {
15771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15772       };
15773     }
15774   }
15775
15776   jresult = result;
15777   return jresult;
15778 }
15779
15780
15781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15782   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15783
15784   arg1 = (Dali::Property::Key *)jarg1;
15785   {
15786     try {
15787       delete arg1;
15788     } catch (std::out_of_range& e) {
15789       {
15790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15791       };
15792     } catch (std::exception& e) {
15793       {
15794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15795       };
15796     } catch (Dali::DaliException e) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15799       };
15800     } catch (...) {
15801       {
15802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15803       };
15804     }
15805   }
15806
15807 }
15808
15809
15810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15811   void * jresult ;
15812   Dali::Property::Map *result = 0 ;
15813
15814   {
15815     try {
15816       result = (Dali::Property::Map *)new Dali::Property::Map();
15817     } catch (std::out_of_range& e) {
15818       {
15819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (std::exception& e) {
15822       {
15823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (Dali::DaliException e) {
15826       {
15827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15828       };
15829     } catch (...) {
15830       {
15831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15832       };
15833     }
15834   }
15835
15836   jresult = (void *)result;
15837   return jresult;
15838 }
15839
15840
15841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15842   void * jresult ;
15843   Dali::Property::Map *arg1 = 0 ;
15844   Dali::Property::Map *result = 0 ;
15845
15846   arg1 = (Dali::Property::Map *)jarg1;
15847   if (!arg1) {
15848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15849     return 0;
15850   }
15851   {
15852     try {
15853       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15854     } catch (std::out_of_range& e) {
15855       {
15856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15857       };
15858     } catch (std::exception& e) {
15859       {
15860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15861       };
15862     } catch (Dali::DaliException e) {
15863       {
15864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15865       };
15866     } catch (...) {
15867       {
15868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15869       };
15870     }
15871   }
15872
15873   jresult = (void *)result;
15874   return jresult;
15875 }
15876
15877
15878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15879   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15880
15881   arg1 = (Dali::Property::Map *)jarg1;
15882   {
15883     try {
15884       delete arg1;
15885     } catch (std::out_of_range& e) {
15886       {
15887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15888       };
15889     } catch (std::exception& e) {
15890       {
15891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15892       };
15893     } catch (Dali::DaliException e) {
15894       {
15895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15896       };
15897     } catch (...) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15900       };
15901     }
15902   }
15903
15904 }
15905
15906
15907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15908   unsigned long jresult ;
15909   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15910   Dali::Property::Map::SizeType result;
15911
15912   arg1 = (Dali::Property::Map *)jarg1;
15913   {
15914     try {
15915       result = ((Dali::Property::Map const *)arg1)->Count();
15916     } catch (std::out_of_range& e) {
15917       {
15918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (std::exception& e) {
15921       {
15922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (Dali::DaliException e) {
15925       {
15926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934
15935   jresult = (unsigned long)result;
15936   return jresult;
15937 }
15938
15939
15940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15941   unsigned int jresult ;
15942   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15943   bool result;
15944
15945   arg1 = (Dali::Property::Map *)jarg1;
15946   {
15947     try {
15948       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15949     } catch (std::out_of_range& e) {
15950       {
15951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (std::exception& e) {
15954       {
15955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15956       };
15957     } catch (Dali::DaliException e) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15960       };
15961     } catch (...) {
15962       {
15963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15964       };
15965     }
15966   }
15967
15968   jresult = result;
15969   return jresult;
15970 }
15971
15972
15973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15974   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15975   char *arg2 = (char *) 0 ;
15976   Dali::Property::Value *arg3 = 0 ;
15977
15978   arg1 = (Dali::Property::Map *)jarg1;
15979   arg2 = (char *)jarg2;
15980   arg3 = (Dali::Property::Value *)jarg3;
15981   if (!arg3) {
15982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15983     return ;
15984   }
15985   {
15986     try {
15987       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15988     } catch (std::out_of_range& e) {
15989       {
15990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15991       };
15992     } catch (std::exception& e) {
15993       {
15994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15995       };
15996     } catch (Dali::DaliException e) {
15997       {
15998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15999       };
16000     } catch (...) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16003       };
16004     }
16005   }
16006
16007 }
16008
16009
16010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16011   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16012   Dali::Property::Index arg2 ;
16013   Dali::Property::Value *arg3 = 0 ;
16014
16015   arg1 = (Dali::Property::Map *)jarg1;
16016   arg2 = (Dali::Property::Index)jarg2;
16017   arg3 = (Dali::Property::Value *)jarg3;
16018   if (!arg3) {
16019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16020     return ;
16021   }
16022   {
16023     try {
16024       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16025     } catch (std::out_of_range& e) {
16026       {
16027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16028       };
16029     } catch (std::exception& e) {
16030       {
16031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16032       };
16033     } catch (Dali::DaliException e) {
16034       {
16035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16036       };
16037     } catch (...) {
16038       {
16039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16040       };
16041     }
16042   }
16043
16044 }
16045
16046
16047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16048   void * jresult ;
16049   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16050   char *arg2 = (char *) 0 ;
16051   Dali::Property::Value *arg3 = 0 ;
16052   Dali::Property::Map *result = 0 ;
16053
16054   arg1 = (Dali::Property::Map *)jarg1;
16055   arg2 = (char *)jarg2;
16056   arg3 = (Dali::Property::Value *)jarg3;
16057   if (!arg3) {
16058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16059     return 0;
16060   }
16061   {
16062     try {
16063       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16064     } catch (std::out_of_range& e) {
16065       {
16066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16067       };
16068     } catch (std::exception& e) {
16069       {
16070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16071       };
16072     } catch (Dali::DaliException e) {
16073       {
16074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16075       };
16076     } catch (...) {
16077       {
16078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16079       };
16080     }
16081   }
16082
16083   jresult = (void *)result;
16084   return jresult;
16085 }
16086
16087
16088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16089   void * jresult ;
16090   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16091   Dali::Property::Index arg2 ;
16092   Dali::Property::Value *arg3 = 0 ;
16093   Dali::Property::Map *result = 0 ;
16094
16095   arg1 = (Dali::Property::Map *)jarg1;
16096   arg2 = (Dali::Property::Index)jarg2;
16097   arg3 = (Dali::Property::Value *)jarg3;
16098   if (!arg3) {
16099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16100     return 0;
16101   }
16102   {
16103     try {
16104       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16105     } catch (std::out_of_range& e) {
16106       {
16107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16108       };
16109     } catch (std::exception& e) {
16110       {
16111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16112       };
16113     } catch (Dali::DaliException e) {
16114       {
16115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16120       };
16121     }
16122   }
16123
16124   jresult = (void *)result;
16125   return jresult;
16126 }
16127
16128
16129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16130   void * jresult ;
16131   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16132   Dali::Property::Map::SizeType arg2 ;
16133   Dali::Property::Value *result = 0 ;
16134
16135   arg1 = (Dali::Property::Map *)jarg1;
16136   arg2 = (Dali::Property::Map::SizeType)jarg2;
16137   {
16138     try {
16139       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16140     } catch (std::out_of_range& e) {
16141       {
16142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (std::exception& e) {
16145       {
16146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16147       };
16148     } catch (Dali::DaliException e) {
16149       {
16150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16151       };
16152     } catch (...) {
16153       {
16154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16155       };
16156     }
16157   }
16158
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16165   char * jresult ;
16166   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16167   Dali::Property::Map::SizeType arg2 ;
16168   std::string *result = 0 ;
16169
16170   arg1 = (Dali::Property::Map *)jarg1;
16171   arg2 = (Dali::Property::Map::SizeType)jarg2;
16172   {
16173     try {
16174       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16175     } catch (std::out_of_range& e) {
16176       {
16177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16178       };
16179     } catch (std::exception& e) {
16180       {
16181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16182       };
16183     } catch (Dali::DaliException e) {
16184       {
16185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16186       };
16187     } catch (...) {
16188       {
16189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16190       };
16191     }
16192   }
16193
16194   jresult = SWIG_csharp_string_callback(result->c_str());
16195   return jresult;
16196 }
16197
16198
16199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16200   void * jresult ;
16201   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16202   Dali::Property::Map::SizeType arg2 ;
16203   SwigValueWrapper< Dali::Property::Key > result;
16204
16205   arg1 = (Dali::Property::Map *)jarg1;
16206   arg2 = (Dali::Property::Map::SizeType)jarg2;
16207   {
16208     try {
16209       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16210     } catch (std::out_of_range& e) {
16211       {
16212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16213       };
16214     } catch (std::exception& e) {
16215       {
16216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16217       };
16218     } catch (Dali::DaliException e) {
16219       {
16220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16221       };
16222     } catch (...) {
16223       {
16224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16225       };
16226     }
16227   }
16228
16229   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16230   return jresult;
16231 }
16232
16233
16234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16235   void * jresult ;
16236   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16237   Dali::Property::Map::SizeType arg2 ;
16238   StringValuePair *result = 0 ;
16239
16240   arg1 = (Dali::Property::Map *)jarg1;
16241   arg2 = (Dali::Property::Map::SizeType)jarg2;
16242   {
16243     try {
16244       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16245     } catch (std::out_of_range& e) {
16246       {
16247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16248       };
16249     } catch (std::exception& e) {
16250       {
16251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16252       };
16253     } catch (Dali::DaliException e) {
16254       {
16255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16256       };
16257     } catch (...) {
16258       {
16259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16260       };
16261     }
16262   }
16263
16264   jresult = (void *)result;
16265   return jresult;
16266 }
16267
16268
16269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16270   void * jresult ;
16271   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16272   char *arg2 = (char *) 0 ;
16273   Dali::Property::Value *result = 0 ;
16274
16275   arg1 = (Dali::Property::Map *)jarg1;
16276   arg2 = (char *)jarg2;
16277   {
16278     try {
16279       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16280     } catch (std::out_of_range& e) {
16281       {
16282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16283       };
16284     } catch (std::exception& e) {
16285       {
16286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16287       };
16288     } catch (Dali::DaliException e) {
16289       {
16290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16291       };
16292     } catch (...) {
16293       {
16294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16295       };
16296     }
16297   }
16298
16299   jresult = (void *)result;
16300   return jresult;
16301 }
16302
16303
16304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16305   void * jresult ;
16306   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16307   Dali::Property::Index arg2 ;
16308   Dali::Property::Value *result = 0 ;
16309
16310   arg1 = (Dali::Property::Map *)jarg1;
16311   arg2 = (Dali::Property::Index)jarg2;
16312   {
16313     try {
16314       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16315     } catch (std::out_of_range& e) {
16316       {
16317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16318       };
16319     } catch (std::exception& e) {
16320       {
16321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16322       };
16323     } catch (Dali::DaliException e) {
16324       {
16325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16326       };
16327     } catch (...) {
16328       {
16329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16330       };
16331     }
16332   }
16333
16334   jresult = (void *)result;
16335   return jresult;
16336 }
16337
16338
16339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16340   void * jresult ;
16341   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16342   Dali::Property::Index arg2 ;
16343   std::string *arg3 = 0 ;
16344   Dali::Property::Value *result = 0 ;
16345
16346   arg1 = (Dali::Property::Map *)jarg1;
16347   arg2 = (Dali::Property::Index)jarg2;
16348   if (!jarg3) {
16349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16350     return 0;
16351   }
16352   std::string arg3_str(jarg3);
16353   arg3 = &arg3_str;
16354   {
16355     try {
16356       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16357     } catch (std::out_of_range& e) {
16358       {
16359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16360       };
16361     } catch (std::exception& e) {
16362       {
16363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (Dali::DaliException e) {
16366       {
16367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16368       };
16369     } catch (...) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16372       };
16373     }
16374   }
16375
16376   jresult = (void *)result;
16377
16378   //argout typemap for const std::string&
16379
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16385   void * jresult ;
16386   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16387   std::string *arg2 = 0 ;
16388   Dali::Property::Type arg3 ;
16389   Dali::Property::Value *result = 0 ;
16390
16391   arg1 = (Dali::Property::Map *)jarg1;
16392   if (!jarg2) {
16393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16394     return 0;
16395   }
16396   std::string arg2_str(jarg2);
16397   arg2 = &arg2_str;
16398   arg3 = (Dali::Property::Type)jarg3;
16399   {
16400     try {
16401       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16402     } catch (std::out_of_range& e) {
16403       {
16404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (std::exception& e) {
16407       {
16408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16409       };
16410     } catch (Dali::DaliException e) {
16411       {
16412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16413       };
16414     } catch (...) {
16415       {
16416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16417       };
16418     }
16419   }
16420
16421   jresult = (void *)result;
16422
16423   //argout typemap for const std::string&
16424
16425   return jresult;
16426 }
16427
16428
16429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16430   void * jresult ;
16431   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16432   Dali::Property::Index arg2 ;
16433   Dali::Property::Type arg3 ;
16434   Dali::Property::Value *result = 0 ;
16435
16436   arg1 = (Dali::Property::Map *)jarg1;
16437   arg2 = (Dali::Property::Index)jarg2;
16438   arg3 = (Dali::Property::Type)jarg3;
16439   {
16440     try {
16441       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16442     } catch (std::out_of_range& e) {
16443       {
16444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16445       };
16446     } catch (std::exception& e) {
16447       {
16448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16449       };
16450     } catch (Dali::DaliException e) {
16451       {
16452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16453       };
16454     } catch (...) {
16455       {
16456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16457       };
16458     }
16459   }
16460
16461   jresult = (void *)result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16467   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16468
16469   arg1 = (Dali::Property::Map *)jarg1;
16470   {
16471     try {
16472       (arg1)->Clear();
16473     } catch (std::out_of_range& e) {
16474       {
16475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16476       };
16477     } catch (std::exception& e) {
16478       {
16479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16480       };
16481     } catch (Dali::DaliException e) {
16482       {
16483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16484       };
16485     } catch (...) {
16486       {
16487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16488       };
16489     }
16490   }
16491
16492 }
16493
16494
16495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16497   Dali::Property::Map *arg2 = 0 ;
16498
16499   arg1 = (Dali::Property::Map *)jarg1;
16500   arg2 = (Dali::Property::Map *)jarg2;
16501   if (!arg2) {
16502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16503     return ;
16504   }
16505   {
16506     try {
16507       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16515       };
16516     } catch (Dali::DaliException e) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16519       };
16520     } catch (...) {
16521       {
16522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16523       };
16524     }
16525   }
16526
16527 }
16528
16529
16530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16531   void * jresult ;
16532   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16533   std::string *arg2 = 0 ;
16534   Dali::Property::Value *result = 0 ;
16535
16536   arg1 = (Dali::Property::Map *)jarg1;
16537   if (!jarg2) {
16538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16539     return 0;
16540   }
16541   std::string arg2_str(jarg2);
16542   arg2 = &arg2_str;
16543   {
16544     try {
16545       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16546     } catch (std::out_of_range& e) {
16547       {
16548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16549       };
16550     } catch (std::exception& e) {
16551       {
16552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16553       };
16554     } catch (Dali::DaliException e) {
16555       {
16556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16557       };
16558     } catch (...) {
16559       {
16560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16561       };
16562     }
16563   }
16564
16565   jresult = (void *)result;
16566
16567   //argout typemap for const std::string&
16568
16569   return jresult;
16570 }
16571
16572
16573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16574   void * jresult ;
16575   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16576   Dali::Property::Index arg2 ;
16577   Dali::Property::Value *result = 0 ;
16578
16579   arg1 = (Dali::Property::Map *)jarg1;
16580   arg2 = (Dali::Property::Index)jarg2;
16581   {
16582     try {
16583       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16584     } catch (std::out_of_range& e) {
16585       {
16586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16587       };
16588     } catch (std::exception& e) {
16589       {
16590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16591       };
16592     } catch (Dali::DaliException e) {
16593       {
16594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16595       };
16596     } catch (...) {
16597       {
16598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16599       };
16600     }
16601   }
16602
16603   jresult = (void *)result;
16604   return jresult;
16605 }
16606
16607
16608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16609   void * jresult ;
16610   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16611   Dali::Property::Map *arg2 = 0 ;
16612   Dali::Property::Map *result = 0 ;
16613
16614   arg1 = (Dali::Property::Map *)jarg1;
16615   arg2 = (Dali::Property::Map *)jarg2;
16616   if (!arg2) {
16617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16618     return 0;
16619   }
16620   {
16621     try {
16622       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16623     } catch (std::out_of_range& e) {
16624       {
16625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16626       };
16627     } catch (std::exception& e) {
16628       {
16629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16630       };
16631     } catch (Dali::DaliException e) {
16632       {
16633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16634       };
16635     } catch (...) {
16636       {
16637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16638       };
16639     }
16640   }
16641
16642   jresult = (void *)result;
16643   return jresult;
16644 }
16645
16646
16647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16648   void * jresult ;
16649   Dali::Property::Value *result = 0 ;
16650
16651   {
16652     try {
16653       result = (Dali::Property::Value *)new Dali::Property::Value();
16654     } catch (std::out_of_range& e) {
16655       {
16656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16657       };
16658     } catch (std::exception& e) {
16659       {
16660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16661       };
16662     } catch (Dali::DaliException e) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16665       };
16666     } catch (...) {
16667       {
16668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16669       };
16670     }
16671   }
16672
16673   jresult = (void *)result;
16674   return jresult;
16675 }
16676
16677
16678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16679   void * jresult ;
16680   bool arg1 ;
16681   Dali::Property::Value *result = 0 ;
16682
16683   arg1 = jarg1 ? true : false;
16684   {
16685     try {
16686       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16694       };
16695     } catch (Dali::DaliException e) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16698       };
16699     } catch (...) {
16700       {
16701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16702       };
16703     }
16704   }
16705
16706   jresult = (void *)result;
16707   return jresult;
16708 }
16709
16710
16711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16712   void * jresult ;
16713   int arg1 ;
16714   Dali::Property::Value *result = 0 ;
16715
16716   arg1 = (int)jarg1;
16717   {
16718     try {
16719       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16720     } catch (std::out_of_range& e) {
16721       {
16722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16723       };
16724     } catch (std::exception& e) {
16725       {
16726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16727       };
16728     } catch (Dali::DaliException e) {
16729       {
16730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16731       };
16732     } catch (...) {
16733       {
16734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16735       };
16736     }
16737   }
16738
16739   jresult = (void *)result;
16740   return jresult;
16741 }
16742
16743
16744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16745   void * jresult ;
16746   float arg1 ;
16747   Dali::Property::Value *result = 0 ;
16748
16749   arg1 = (float)jarg1;
16750   {
16751     try {
16752       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16753     } catch (std::out_of_range& e) {
16754       {
16755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16756       };
16757     } catch (std::exception& e) {
16758       {
16759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16760       };
16761     } catch (Dali::DaliException e) {
16762       {
16763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16764       };
16765     } catch (...) {
16766       {
16767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16768       };
16769     }
16770   }
16771
16772   jresult = (void *)result;
16773   return jresult;
16774 }
16775
16776
16777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16778   void * jresult ;
16779   Dali::Vector2 *arg1 = 0 ;
16780   Dali::Property::Value *result = 0 ;
16781
16782   arg1 = (Dali::Vector2 *)jarg1;
16783   if (!arg1) {
16784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16785     return 0;
16786   }
16787   {
16788     try {
16789       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16790     } catch (std::out_of_range& e) {
16791       {
16792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16793       };
16794     } catch (std::exception& e) {
16795       {
16796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16797       };
16798     } catch (Dali::DaliException e) {
16799       {
16800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16801       };
16802     } catch (...) {
16803       {
16804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16805       };
16806     }
16807   }
16808
16809   jresult = (void *)result;
16810   return jresult;
16811 }
16812
16813
16814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16815   void * jresult ;
16816   Dali::Vector3 *arg1 = 0 ;
16817   Dali::Property::Value *result = 0 ;
16818
16819   arg1 = (Dali::Vector3 *)jarg1;
16820   if (!arg1) {
16821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16822     return 0;
16823   }
16824   {
16825     try {
16826       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16827     } catch (std::out_of_range& e) {
16828       {
16829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16830       };
16831     } catch (std::exception& e) {
16832       {
16833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16834       };
16835     } catch (Dali::DaliException e) {
16836       {
16837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16838       };
16839     } catch (...) {
16840       {
16841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16842       };
16843     }
16844   }
16845
16846   jresult = (void *)result;
16847   return jresult;
16848 }
16849
16850
16851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16852   void * jresult ;
16853   Dali::Vector4 *arg1 = 0 ;
16854   Dali::Property::Value *result = 0 ;
16855
16856   arg1 = (Dali::Vector4 *)jarg1;
16857   if (!arg1) {
16858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16859     return 0;
16860   }
16861   {
16862     try {
16863       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16864     } catch (std::out_of_range& e) {
16865       {
16866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16867       };
16868     } catch (std::exception& e) {
16869       {
16870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16871       };
16872     } catch (Dali::DaliException e) {
16873       {
16874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16875       };
16876     } catch (...) {
16877       {
16878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16879       };
16880     }
16881   }
16882
16883   jresult = (void *)result;
16884   return jresult;
16885 }
16886
16887
16888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16889   void * jresult ;
16890   Dali::Matrix3 *arg1 = 0 ;
16891   Dali::Property::Value *result = 0 ;
16892
16893   arg1 = (Dali::Matrix3 *)jarg1;
16894   if (!arg1) {
16895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16896     return 0;
16897   }
16898   {
16899     try {
16900       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16901     } catch (std::out_of_range& e) {
16902       {
16903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (std::exception& e) {
16906       {
16907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16908       };
16909     } catch (Dali::DaliException e) {
16910       {
16911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16912       };
16913     } catch (...) {
16914       {
16915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16916       };
16917     }
16918   }
16919
16920   jresult = (void *)result;
16921   return jresult;
16922 }
16923
16924
16925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16926   void * jresult ;
16927   Dali::Matrix *arg1 = 0 ;
16928   Dali::Property::Value *result = 0 ;
16929
16930   arg1 = (Dali::Matrix *)jarg1;
16931   if (!arg1) {
16932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16933     return 0;
16934   }
16935   {
16936     try {
16937       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16938     } catch (std::out_of_range& e) {
16939       {
16940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16941       };
16942     } catch (std::exception& e) {
16943       {
16944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16945       };
16946     } catch (Dali::DaliException e) {
16947       {
16948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16949       };
16950     } catch (...) {
16951       {
16952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16953       };
16954     }
16955   }
16956
16957   jresult = (void *)result;
16958   return jresult;
16959 }
16960
16961
16962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16963   void * jresult ;
16964   Dali::Rect< int > *arg1 = 0 ;
16965   Dali::Property::Value *result = 0 ;
16966
16967   arg1 = (Dali::Rect< int > *)jarg1;
16968   if (!arg1) {
16969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16970     return 0;
16971   }
16972   {
16973     try {
16974       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16975     } catch (std::out_of_range& e) {
16976       {
16977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16978       };
16979     } catch (std::exception& e) {
16980       {
16981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16982       };
16983     } catch (Dali::DaliException e) {
16984       {
16985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16986       };
16987     } catch (...) {
16988       {
16989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16990       };
16991     }
16992   }
16993
16994   jresult = (void *)result;
16995   return jresult;
16996 }
16997
16998
16999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17000   void * jresult ;
17001   Dali::AngleAxis *arg1 = 0 ;
17002   Dali::Property::Value *result = 0 ;
17003
17004   arg1 = (Dali::AngleAxis *)jarg1;
17005   if (!arg1) {
17006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17007     return 0;
17008   }
17009   {
17010     try {
17011       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17012     } catch (std::out_of_range& e) {
17013       {
17014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17015       };
17016     } catch (std::exception& e) {
17017       {
17018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17019       };
17020     } catch (Dali::DaliException e) {
17021       {
17022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17023       };
17024     } catch (...) {
17025       {
17026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17027       };
17028     }
17029   }
17030
17031   jresult = (void *)result;
17032   return jresult;
17033 }
17034
17035
17036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17037   void * jresult ;
17038   Dali::Quaternion *arg1 = 0 ;
17039   Dali::Property::Value *result = 0 ;
17040
17041   arg1 = (Dali::Quaternion *)jarg1;
17042   if (!arg1) {
17043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17044     return 0;
17045   }
17046   {
17047     try {
17048       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17049     } catch (std::out_of_range& e) {
17050       {
17051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17052       };
17053     } catch (std::exception& e) {
17054       {
17055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17056       };
17057     } catch (Dali::DaliException e) {
17058       {
17059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17060       };
17061     } catch (...) {
17062       {
17063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17064       };
17065     }
17066   }
17067
17068   jresult = (void *)result;
17069   return jresult;
17070 }
17071
17072
17073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17074   void * jresult ;
17075   std::string *arg1 = 0 ;
17076   Dali::Property::Value *result = 0 ;
17077
17078   if (!jarg1) {
17079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17080     return 0;
17081   }
17082   std::string arg1_str(jarg1);
17083   arg1 = &arg1_str;
17084   {
17085     try {
17086       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17087     } catch (std::out_of_range& e) {
17088       {
17089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (std::exception& e) {
17092       {
17093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17094       };
17095     } catch (Dali::DaliException e) {
17096       {
17097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17098       };
17099     } catch (...) {
17100       {
17101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17102       };
17103     }
17104   }
17105
17106   jresult = (void *)result;
17107
17108   //argout typemap for const std::string&
17109
17110   return jresult;
17111 }
17112
17113
17114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17115   void * jresult ;
17116   Dali::Property::Array *arg1 = 0 ;
17117   Dali::Property::Value *result = 0 ;
17118
17119   arg1 = (Dali::Property::Array *)jarg1;
17120   if (!arg1) {
17121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17122     return 0;
17123   }
17124   {
17125     try {
17126       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17127     } catch (std::out_of_range& e) {
17128       {
17129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17130       };
17131     } catch (std::exception& e) {
17132       {
17133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17134       };
17135     } catch (Dali::DaliException e) {
17136       {
17137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17138       };
17139     } catch (...) {
17140       {
17141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17142       };
17143     }
17144   }
17145
17146   jresult = (void *)result;
17147   return jresult;
17148 }
17149
17150
17151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17152   void * jresult ;
17153   Dali::Property::Map *arg1 = 0 ;
17154   Dali::Property::Value *result = 0 ;
17155
17156   arg1 = (Dali::Property::Map *)jarg1;
17157   if (!arg1) {
17158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17159     return 0;
17160   }
17161   {
17162     try {
17163       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17164     } catch (std::out_of_range& e) {
17165       {
17166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17167       };
17168     } catch (std::exception& e) {
17169       {
17170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17171       };
17172     } catch (Dali::DaliException e) {
17173       {
17174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17175       };
17176     } catch (...) {
17177       {
17178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17179       };
17180     }
17181   }
17182
17183   jresult = (void *)result;
17184   return jresult;
17185 }
17186
17187
17188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17189   void * jresult ;
17190   Extents *arg1 = 0 ;
17191   Dali::Property::Value *result = 0 ;
17192
17193   arg1 = (Extents *)jarg1;
17194   if (!arg1) {
17195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17196     return 0;
17197   }
17198   {
17199     try {
17200       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17201     } catch (std::out_of_range& e) {
17202       {
17203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17204       };
17205     } catch (std::exception& e) {
17206       {
17207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17208       };
17209     } catch (...) {
17210       {
17211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17212       };
17213     }
17214   }
17215   jresult = (void *)result;
17216   return jresult;
17217 }
17218
17219
17220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17221   void * jresult ;
17222   Dali::Property::Type arg1 ;
17223   Dali::Property::Value *result = 0 ;
17224
17225   arg1 = (Dali::Property::Type)jarg1;
17226   {
17227     try {
17228       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17229     } catch (std::out_of_range& e) {
17230       {
17231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17232       };
17233     } catch (std::exception& e) {
17234       {
17235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17236       };
17237     } catch (Dali::DaliException e) {
17238       {
17239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17240       };
17241     } catch (...) {
17242       {
17243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17244       };
17245     }
17246   }
17247
17248   jresult = (void *)result;
17249   return jresult;
17250 }
17251
17252
17253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17254   void * jresult ;
17255   Dali::Property::Value *arg1 = 0 ;
17256   Dali::Property::Value *result = 0 ;
17257
17258   arg1 = (Dali::Property::Value *)jarg1;
17259   if (!arg1) {
17260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17261     return 0;
17262   }
17263   {
17264     try {
17265       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17266     } catch (std::out_of_range& e) {
17267       {
17268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17269       };
17270     } catch (std::exception& e) {
17271       {
17272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17273       };
17274     } catch (Dali::DaliException e) {
17275       {
17276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17277       };
17278     } catch (...) {
17279       {
17280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17281       };
17282     }
17283   }
17284
17285   jresult = (void *)result;
17286   return jresult;
17287 }
17288
17289
17290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17291   void * jresult ;
17292   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17293   Dali::Property::Value *arg2 = 0 ;
17294   Dali::Property::Value *result = 0 ;
17295
17296   arg1 = (Dali::Property::Value *)jarg1;
17297   arg2 = (Dali::Property::Value *)jarg2;
17298   if (!arg2) {
17299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17300     return 0;
17301   }
17302   {
17303     try {
17304       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17305     } catch (std::out_of_range& e) {
17306       {
17307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17308       };
17309     } catch (std::exception& e) {
17310       {
17311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17312       };
17313     } catch (Dali::DaliException e) {
17314       {
17315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17316       };
17317     } catch (...) {
17318       {
17319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17320       };
17321     }
17322   }
17323
17324   jresult = (void *)result;
17325   return jresult;
17326 }
17327
17328
17329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17330   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17331
17332   arg1 = (Dali::Property::Value *)jarg1;
17333   {
17334     try {
17335       delete arg1;
17336     } catch (std::out_of_range& e) {
17337       {
17338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17339       };
17340     } catch (std::exception& e) {
17341       {
17342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17343       };
17344     } catch (Dali::DaliException e) {
17345       {
17346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17347       };
17348     } catch (...) {
17349       {
17350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17351       };
17352     }
17353   }
17354
17355 }
17356
17357
17358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17359   int jresult ;
17360   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17361   Dali::Property::Type result;
17362
17363   arg1 = (Dali::Property::Value *)jarg1;
17364   {
17365     try {
17366       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17367     } catch (std::out_of_range& e) {
17368       {
17369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (std::exception& e) {
17372       {
17373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17374       };
17375     } catch (Dali::DaliException e) {
17376       {
17377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17378       };
17379     } catch (...) {
17380       {
17381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17382       };
17383     }
17384   }
17385
17386   jresult = (int)result;
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17392   unsigned int jresult ;
17393   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17394   bool *arg2 = 0 ;
17395   bool result;
17396
17397   arg1 = (Dali::Property::Value *)jarg1;
17398   arg2 = (bool *)jarg2;
17399   {
17400     try {
17401       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17402     } catch (std::out_of_range& e) {
17403       {
17404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17405       };
17406     } catch (std::exception& e) {
17407       {
17408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17409       };
17410     } catch (Dali::DaliException e) {
17411       {
17412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17413       };
17414     } catch (...) {
17415       {
17416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17417       };
17418     }
17419   }
17420
17421   jresult = result;
17422   return jresult;
17423 }
17424
17425
17426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17427   unsigned int jresult ;
17428   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17429   float *arg2 = 0 ;
17430   bool result;
17431
17432   arg1 = (Dali::Property::Value *)jarg1;
17433   arg2 = (float *)jarg2;
17434   {
17435     try {
17436       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17437     } catch (std::out_of_range& e) {
17438       {
17439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17440       };
17441     } catch (std::exception& e) {
17442       {
17443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17444       };
17445     } catch (Dali::DaliException e) {
17446       {
17447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17448       };
17449     } catch (...) {
17450       {
17451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17452       };
17453     }
17454   }
17455
17456   jresult = result;
17457   return jresult;
17458 }
17459
17460
17461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17462   unsigned int jresult ;
17463   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17464   int *arg2 = 0 ;
17465   bool result;
17466
17467   arg1 = (Dali::Property::Value *)jarg1;
17468   arg2 = (int *)jarg2;
17469   {
17470     try {
17471       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17472     } catch (std::out_of_range& e) {
17473       {
17474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17475       };
17476     } catch (std::exception& e) {
17477       {
17478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17479       };
17480     } catch (Dali::DaliException e) {
17481       {
17482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17483       };
17484     } catch (...) {
17485       {
17486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17487       };
17488     }
17489   }
17490
17491   jresult = result;
17492   return jresult;
17493 }
17494
17495
17496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17497   unsigned int jresult ;
17498   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17499   Dali::Rect< int > *arg2 = 0 ;
17500   bool result;
17501
17502   arg1 = (Dali::Property::Value *)jarg1;
17503   arg2 = (Dali::Rect< int > *)jarg2;
17504   if (!arg2) {
17505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17506     return 0;
17507   }
17508   {
17509     try {
17510       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17511     } catch (std::out_of_range& e) {
17512       {
17513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (std::exception& e) {
17516       {
17517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17518       };
17519     } catch (Dali::DaliException e) {
17520       {
17521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17522       };
17523     } catch (...) {
17524       {
17525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17526       };
17527     }
17528   }
17529
17530   jresult = result;
17531   return jresult;
17532 }
17533
17534
17535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17536   unsigned int jresult ;
17537   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17538   Dali::Vector2 *arg2 = 0 ;
17539   bool result;
17540
17541   arg1 = (Dali::Property::Value *)jarg1;
17542   arg2 = (Dali::Vector2 *)jarg2;
17543   if (!arg2) {
17544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17545     return 0;
17546   }
17547   {
17548     try {
17549       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17550     } catch (std::out_of_range& e) {
17551       {
17552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17553       };
17554     } catch (std::exception& e) {
17555       {
17556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17557       };
17558     } catch (Dali::DaliException e) {
17559       {
17560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17561       };
17562     } catch (...) {
17563       {
17564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17565       };
17566     }
17567   }
17568
17569   jresult = result;
17570   return jresult;
17571 }
17572
17573
17574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17575   unsigned int jresult ;
17576   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17577   Dali::Vector3 *arg2 = 0 ;
17578   bool result;
17579
17580   arg1 = (Dali::Property::Value *)jarg1;
17581   arg2 = (Dali::Vector3 *)jarg2;
17582   if (!arg2) {
17583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17584     return 0;
17585   }
17586   {
17587     try {
17588       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17589     } catch (std::out_of_range& e) {
17590       {
17591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17592       };
17593     } catch (std::exception& e) {
17594       {
17595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17596       };
17597     } catch (Dali::DaliException e) {
17598       {
17599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17600       };
17601     } catch (...) {
17602       {
17603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17604       };
17605     }
17606   }
17607
17608   jresult = result;
17609   return jresult;
17610 }
17611
17612
17613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17614   unsigned int jresult ;
17615   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17616   Dali::Vector4 *arg2 = 0 ;
17617   bool result;
17618
17619   arg1 = (Dali::Property::Value *)jarg1;
17620   arg2 = (Dali::Vector4 *)jarg2;
17621   if (!arg2) {
17622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17623     return 0;
17624   }
17625   {
17626     try {
17627       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17628     } catch (std::out_of_range& e) {
17629       {
17630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17631       };
17632     } catch (std::exception& e) {
17633       {
17634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17635       };
17636     } catch (Dali::DaliException e) {
17637       {
17638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17639       };
17640     } catch (...) {
17641       {
17642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17643       };
17644     }
17645   }
17646
17647   jresult = result;
17648   return jresult;
17649 }
17650
17651
17652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17653   unsigned int jresult ;
17654   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17655   Dali::Matrix3 *arg2 = 0 ;
17656   bool result;
17657
17658   arg1 = (Dali::Property::Value *)jarg1;
17659   arg2 = (Dali::Matrix3 *)jarg2;
17660   if (!arg2) {
17661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17662     return 0;
17663   }
17664   {
17665     try {
17666       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17667     } catch (std::out_of_range& e) {
17668       {
17669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17670       };
17671     } catch (std::exception& e) {
17672       {
17673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17674       };
17675     } catch (Dali::DaliException e) {
17676       {
17677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17678       };
17679     } catch (...) {
17680       {
17681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17682       };
17683     }
17684   }
17685
17686   jresult = result;
17687   return jresult;
17688 }
17689
17690
17691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17692   unsigned int jresult ;
17693   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17694   Dali::Matrix *arg2 = 0 ;
17695   bool result;
17696
17697   arg1 = (Dali::Property::Value *)jarg1;
17698   arg2 = (Dali::Matrix *)jarg2;
17699   if (!arg2) {
17700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17701     return 0;
17702   }
17703   {
17704     try {
17705       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17706     } catch (std::out_of_range& e) {
17707       {
17708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17709       };
17710     } catch (std::exception& e) {
17711       {
17712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17713       };
17714     } catch (Dali::DaliException e) {
17715       {
17716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17717       };
17718     } catch (...) {
17719       {
17720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17721       };
17722     }
17723   }
17724
17725   jresult = result;
17726   return jresult;
17727 }
17728
17729
17730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17731   unsigned int jresult ;
17732   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17733   Dali::AngleAxis *arg2 = 0 ;
17734   bool result;
17735
17736   arg1 = (Dali::Property::Value *)jarg1;
17737   arg2 = (Dali::AngleAxis *)jarg2;
17738   if (!arg2) {
17739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17740     return 0;
17741   }
17742   {
17743     try {
17744       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17745     } catch (std::out_of_range& e) {
17746       {
17747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17748       };
17749     } catch (std::exception& e) {
17750       {
17751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17752       };
17753     } catch (Dali::DaliException e) {
17754       {
17755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17756       };
17757     } catch (...) {
17758       {
17759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17760       };
17761     }
17762   }
17763
17764   jresult = result;
17765   return jresult;
17766 }
17767
17768
17769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17770   unsigned int jresult ;
17771   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17772   Dali::Quaternion *arg2 = 0 ;
17773   bool result;
17774
17775   arg1 = (Dali::Property::Value *)jarg1;
17776   arg2 = (Dali::Quaternion *)jarg2;
17777   if (!arg2) {
17778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17779     return 0;
17780   }
17781   {
17782     try {
17783       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17784     } catch (std::out_of_range& e) {
17785       {
17786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17787       };
17788     } catch (std::exception& e) {
17789       {
17790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17791       };
17792     } catch (Dali::DaliException e) {
17793       {
17794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17795       };
17796     } catch (...) {
17797       {
17798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17799       };
17800     }
17801   }
17802
17803   jresult = result;
17804   return jresult;
17805 }
17806
17807
17808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17809   unsigned int jresult ;
17810   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17811   std::string *arg2 = 0 ;
17812   bool result;
17813
17814   arg1 = (Dali::Property::Value *)jarg1;
17815
17816   //typemap in
17817   std::string temp;
17818   arg2 = &temp;
17819
17820   {
17821     try {
17822       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17823     } catch (std::out_of_range& e) {
17824       {
17825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (std::exception& e) {
17828       {
17829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17830       };
17831     } catch (Dali::DaliException e) {
17832       {
17833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17834       };
17835     } catch (...) {
17836       {
17837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17838       };
17839     }
17840   }
17841
17842   jresult = result;
17843
17844   //Typemap argout in c++ file.
17845   //This will convert c++ string to c# string
17846   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17847
17848   return jresult;
17849 }
17850
17851
17852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17853   unsigned int jresult ;
17854   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17855   Dali::Property::Array *arg2 = 0 ;
17856   bool result;
17857
17858   arg1 = (Dali::Property::Value *)jarg1;
17859   arg2 = (Dali::Property::Array *)jarg2;
17860   if (!arg2) {
17861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17862     return 0;
17863   }
17864   {
17865     try {
17866       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17867     } catch (std::out_of_range& e) {
17868       {
17869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17870       };
17871     } catch (std::exception& e) {
17872       {
17873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17874       };
17875     } catch (Dali::DaliException e) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17878       };
17879     } catch (...) {
17880       {
17881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17882       };
17883     }
17884   }
17885
17886   jresult = result;
17887   return jresult;
17888 }
17889
17890
17891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17892   unsigned int jresult ;
17893   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17894   Dali::Property::Map *arg2 = 0 ;
17895   bool result;
17896
17897   arg1 = (Dali::Property::Value *)jarg1;
17898   arg2 = (Dali::Property::Map *)jarg2;
17899   if (!arg2) {
17900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17901     return 0;
17902   }
17903   {
17904     try {
17905       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17906     } catch (std::out_of_range& e) {
17907       {
17908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17909       };
17910     } catch (std::exception& e) {
17911       {
17912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17913       };
17914     } catch (Dali::DaliException e) {
17915       {
17916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17917       };
17918     } catch (...) {
17919       {
17920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17921       };
17922     }
17923   }
17924
17925   jresult = result;
17926   return jresult;
17927 }
17928
17929
17930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17931   unsigned int jresult ;
17932   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17933   Extents *arg2 = 0 ;
17934   bool result;
17935
17936   arg1 = (Dali::Property::Value *)jarg1;
17937   arg2 = (Extents *)jarg2;
17938   if (!arg2) {
17939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17940     return 0;
17941   }
17942   {
17943     try {
17944       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17945     } catch (std::out_of_range& e) {
17946       {
17947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17948       };
17949     } catch (std::exception& e) {
17950       {
17951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17952       };
17953     } catch (...) {
17954       {
17955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17956       };
17957     }
17958   }
17959   jresult = result;
17960   return jresult;
17961 }
17962
17963
17964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17965   void * jresult ;
17966   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17967   Dali::Property::Array *result = 0 ;
17968
17969   arg1 = (Dali::Property::Value *)jarg1;
17970   {
17971     try {
17972       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17973     } catch (std::out_of_range& e) {
17974       {
17975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17976       };
17977     } catch (std::exception& e) {
17978       {
17979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (Dali::DaliException e) {
17982       {
17983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17984       };
17985     } catch (...) {
17986       {
17987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17988       };
17989     }
17990   }
17991
17992   jresult = (void *)result;
17993   return jresult;
17994 }
17995
17996
17997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17998   void * jresult ;
17999   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18000   Dali::Property::Map *result = 0 ;
18001
18002   arg1 = (Dali::Property::Value *)jarg1;
18003   {
18004     try {
18005       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18006     } catch (std::out_of_range& e) {
18007       {
18008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18009       };
18010     } catch (std::exception& e) {
18011       {
18012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18013       };
18014     } catch (Dali::DaliException e) {
18015       {
18016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18017       };
18018     } catch (...) {
18019       {
18020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18021       };
18022     }
18023   }
18024
18025   jresult = (void *)result;
18026   return jresult;
18027 }
18028
18029
18030 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18031   char * jresult ;
18032   Dali::Property::Type arg1 ;
18033   char *result = 0 ;
18034
18035   arg1 = (Dali::Property::Type)jarg1;
18036   {
18037     try {
18038       result = (char *)Dali::PropertyTypes::GetName(arg1);
18039     } catch (std::out_of_range& e) {
18040       {
18041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18042       };
18043     } catch (std::exception& e) {
18044       {
18045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18046       };
18047     } catch (Dali::DaliException e) {
18048       {
18049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18050       };
18051     } catch (...) {
18052       {
18053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18054       };
18055     }
18056   }
18057
18058   jresult = SWIG_csharp_string_callback((const char *)result);
18059   return jresult;
18060 }
18061
18062
18063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18064   unsigned int jresult ;
18065   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18066   std::string *arg2 = 0 ;
18067   Dali::Property::Map *arg3 = 0 ;
18068   bool result;
18069
18070   arg1 = (Dali::BaseObject *)jarg1;
18071   if (!jarg2) {
18072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18073     return 0;
18074   }
18075   std::string arg2_str(jarg2);
18076   arg2 = &arg2_str;
18077   arg3 = (Dali::Property::Map *)jarg3;
18078   if (!arg3) {
18079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18080     return 0;
18081   }
18082   {
18083     try {
18084       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18085     } catch (std::out_of_range& e) {
18086       {
18087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18088       };
18089     } catch (std::exception& e) {
18090       {
18091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18092       };
18093     } catch (Dali::DaliException e) {
18094       {
18095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18096       };
18097     } catch (...) {
18098       {
18099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18100       };
18101     }
18102   }
18103
18104   jresult = result;
18105
18106   //argout typemap for const std::string&
18107
18108   return jresult;
18109 }
18110
18111
18112 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18113   char * jresult ;
18114   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18115   std::string *result = 0 ;
18116
18117   arg1 = (Dali::BaseObject *)jarg1;
18118   {
18119     try {
18120       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18121     } catch (std::out_of_range& e) {
18122       {
18123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18124       };
18125     } catch (std::exception& e) {
18126       {
18127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18128       };
18129     } catch (Dali::DaliException e) {
18130       {
18131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18132       };
18133     } catch (...) {
18134       {
18135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18136       };
18137     }
18138   }
18139
18140   jresult = SWIG_csharp_string_callback(result->c_str());
18141   return jresult;
18142 }
18143
18144
18145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18146   unsigned int jresult ;
18147   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18148   Dali::TypeInfo *arg2 = 0 ;
18149   bool result;
18150
18151   arg1 = (Dali::BaseObject *)jarg1;
18152   arg2 = (Dali::TypeInfo *)jarg2;
18153   if (!arg2) {
18154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18155     return 0;
18156   }
18157   {
18158     try {
18159       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18160     } catch (std::out_of_range& e) {
18161       {
18162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18163       };
18164     } catch (std::exception& e) {
18165       {
18166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18167       };
18168     } catch (Dali::DaliException e) {
18169       {
18170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18171       };
18172     } catch (...) {
18173       {
18174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18175       };
18176     }
18177   }
18178
18179   jresult = result;
18180   return jresult;
18181 }
18182
18183
18184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18185   unsigned int jresult ;
18186   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18187   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18188   std::string *arg3 = 0 ;
18189   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18190   bool result;
18191
18192   arg1 = (Dali::BaseObject *)jarg1;
18193   arg2 = (ConnectionTrackerInterface *)jarg2;
18194   if (!jarg3) {
18195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18196     return 0;
18197   }
18198   std::string arg3_str(jarg3);
18199   arg3 = &arg3_str;
18200   arg4 = (FunctorDelegate *)jarg4;
18201   {
18202     try {
18203       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18204     } catch (std::out_of_range& e) {
18205       {
18206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18207       };
18208     } catch (std::exception& e) {
18209       {
18210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18211       };
18212     } catch (Dali::DaliException e) {
18213       {
18214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18215       };
18216     } catch (...) {
18217       {
18218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18219       };
18220     }
18221   }
18222
18223   jresult = result;
18224
18225   //argout typemap for const std::string&
18226
18227   return jresult;
18228 }
18229
18230
18231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18232   void * jresult ;
18233   Dali::BaseHandle *arg1 = 0 ;
18234   Dali::BaseObject *result = 0 ;
18235
18236   arg1 = (Dali::BaseHandle *)jarg1;
18237   if (!arg1) {
18238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18239     return 0;
18240   }
18241   {
18242     try {
18243       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18244     } catch (std::out_of_range& e) {
18245       {
18246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18247       };
18248     } catch (std::exception& e) {
18249       {
18250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18251       };
18252     } catch (Dali::DaliException e) {
18253       {
18254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18255       };
18256     } catch (...) {
18257       {
18258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18259       };
18260     }
18261   }
18262
18263   jresult = (void *)result;
18264   return jresult;
18265 }
18266
18267
18268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18269   void * jresult ;
18270   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18271   Dali::BaseHandle *result = 0 ;
18272
18273   arg1 = (Dali::BaseObject *)jarg1;
18274   {
18275     try {
18276       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18277     } catch (std::out_of_range& e) {
18278       {
18279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18280       };
18281     } catch (std::exception& e) {
18282       {
18283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18284       };
18285     } catch (Dali::DaliException e) {
18286       {
18287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18288       };
18289     } catch (...) {
18290       {
18291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18292       };
18293     }
18294   }
18295
18296   jresult = (void *)result;
18297   return jresult;
18298 }
18299
18300
18301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18302   void * jresult ;
18303   Dali::BaseHandle *result = 0 ;
18304
18305   {
18306     try {
18307       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18308     } catch (std::out_of_range& e) {
18309       {
18310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18311       };
18312     } catch (std::exception& e) {
18313       {
18314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18315       };
18316     } catch (Dali::DaliException e) {
18317       {
18318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18319       };
18320     } catch (...) {
18321       {
18322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18323       };
18324     }
18325   }
18326
18327   jresult = (void *)result;
18328   return jresult;
18329 }
18330
18331
18332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18333   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18334
18335   arg1 = (Dali::BaseHandle *)jarg1;
18336   {
18337     try {
18338       delete arg1;
18339     } catch (std::out_of_range& e) {
18340       {
18341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18342       };
18343     } catch (std::exception& e) {
18344       {
18345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18346       };
18347     } catch (Dali::DaliException e) {
18348       {
18349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18350       };
18351     } catch (...) {
18352       {
18353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18354       };
18355     }
18356   }
18357
18358 }
18359
18360
18361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18362   void * jresult ;
18363   Dali::BaseHandle *arg1 = 0 ;
18364   Dali::BaseHandle *result = 0 ;
18365
18366   arg1 = (Dali::BaseHandle *)jarg1;
18367   if (!arg1) {
18368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18369     return 0;
18370   }
18371   {
18372     try {
18373       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18374     } catch (std::out_of_range& e) {
18375       {
18376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18377       };
18378     } catch (std::exception& e) {
18379       {
18380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18381       };
18382     } catch (Dali::DaliException e) {
18383       {
18384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18385       };
18386     } catch (...) {
18387       {
18388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18389       };
18390     }
18391   }
18392
18393   jresult = (void *)result;
18394   return jresult;
18395 }
18396
18397
18398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18399   void * jresult ;
18400   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18401   Dali::BaseHandle *arg2 = 0 ;
18402   Dali::BaseHandle *result = 0 ;
18403
18404   arg1 = (Dali::BaseHandle *)jarg1;
18405   arg2 = (Dali::BaseHandle *)jarg2;
18406   if (!arg2) {
18407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18408     return 0;
18409   }
18410   {
18411     try {
18412       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18413     } catch (std::out_of_range& e) {
18414       {
18415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18416       };
18417     } catch (std::exception& e) {
18418       {
18419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18420       };
18421     } catch (Dali::DaliException e) {
18422       {
18423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18424       };
18425     } catch (...) {
18426       {
18427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18428       };
18429     }
18430   }
18431
18432   jresult = (void *)result;
18433   return jresult;
18434 }
18435
18436
18437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18438   unsigned int jresult ;
18439   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18440   std::string *arg2 = 0 ;
18441   Dali::Property::Map *arg3 = 0 ;
18442   bool result;
18443
18444   arg1 = (Dali::BaseHandle *)jarg1;
18445   if (!jarg2) {
18446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18447     return 0;
18448   }
18449   std::string arg2_str(jarg2);
18450   arg2 = &arg2_str;
18451   arg3 = (Dali::Property::Map *)jarg3;
18452   if (!arg3) {
18453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18454     return 0;
18455   }
18456   {
18457     try {
18458       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18459     } catch (std::out_of_range& e) {
18460       {
18461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18462       };
18463     } catch (std::exception& e) {
18464       {
18465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18466       };
18467     } catch (Dali::DaliException e) {
18468       {
18469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18470       };
18471     } catch (...) {
18472       {
18473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18474       };
18475     }
18476   }
18477
18478   jresult = result;
18479
18480   //argout typemap for const std::string&
18481
18482   return jresult;
18483 }
18484
18485
18486 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18487   char * jresult ;
18488   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18489   std::string *result = 0 ;
18490
18491   arg1 = (Dali::BaseHandle *)jarg1;
18492   {
18493     try {
18494       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18495     } catch (std::out_of_range& e) {
18496       {
18497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18498       };
18499     } catch (std::exception& e) {
18500       {
18501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18502       };
18503     } catch (Dali::DaliException e) {
18504       {
18505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18506       };
18507     } catch (...) {
18508       {
18509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18510       };
18511     }
18512   }
18513
18514   jresult = SWIG_csharp_string_callback(result->c_str());
18515   return jresult;
18516 }
18517
18518
18519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18520   unsigned int jresult ;
18521   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18522   Dali::TypeInfo *arg2 = 0 ;
18523   bool result;
18524
18525   arg1 = (Dali::BaseHandle *)jarg1;
18526   arg2 = (Dali::TypeInfo *)jarg2;
18527   if (!arg2) {
18528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18529     return 0;
18530   }
18531   {
18532     try {
18533       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18534     } catch (std::out_of_range& e) {
18535       {
18536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18537       };
18538     } catch (std::exception& e) {
18539       {
18540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18541       };
18542     } catch (Dali::DaliException e) {
18543       {
18544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18545       };
18546     } catch (...) {
18547       {
18548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18549       };
18550     }
18551   }
18552
18553   jresult = result;
18554   return jresult;
18555 }
18556
18557
18558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18559   void * jresult ;
18560   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18561   Dali::BaseObject *result = 0 ;
18562
18563   arg1 = (Dali::BaseHandle *)jarg1;
18564   {
18565     try {
18566       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18567     } catch (std::out_of_range& e) {
18568       {
18569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18570       };
18571     } catch (std::exception& e) {
18572       {
18573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18574       };
18575     } catch (Dali::DaliException e) {
18576       {
18577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18578       };
18579     } catch (...) {
18580       {
18581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18582       };
18583     }
18584   }
18585
18586   jresult = (void *)result;
18587   return jresult;
18588 }
18589
18590
18591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18592   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18593
18594   arg1 = (Dali::BaseHandle *)jarg1;
18595   {
18596     try {
18597       (arg1)->Reset();
18598     } catch (std::out_of_range& e) {
18599       {
18600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18601       };
18602     } catch (std::exception& e) {
18603       {
18604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18605       };
18606     } catch (Dali::DaliException e) {
18607       {
18608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18609       };
18610     } catch (...) {
18611       {
18612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18613       };
18614     }
18615   }
18616
18617 }
18618
18619
18620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18621   unsigned int jresult ;
18622   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18623   Dali::BaseHandle *arg2 = 0 ;
18624   bool result;
18625
18626   arg1 = (Dali::BaseHandle *)jarg1;
18627   arg2 = (Dali::BaseHandle *)jarg2;
18628   if (!arg2) {
18629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18630     return 0;
18631   }
18632   {
18633     try {
18634       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18635     } catch (std::out_of_range& e) {
18636       {
18637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18638       };
18639     } catch (std::exception& e) {
18640       {
18641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18642       };
18643     } catch (Dali::DaliException e) {
18644       {
18645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18646       };
18647     } catch (...) {
18648       {
18649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18650       };
18651     }
18652   }
18653
18654   jresult = result;
18655   return jresult;
18656 }
18657
18658
18659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18660   unsigned int jresult ;
18661   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18662   Dali::BaseHandle *arg2 = 0 ;
18663   bool result;
18664
18665   arg1 = (Dali::BaseHandle *)jarg1;
18666   arg2 = (Dali::BaseHandle *)jarg2;
18667   if (!arg2) {
18668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18669     return 0;
18670   }
18671   {
18672     try {
18673       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18674     } catch (std::out_of_range& e) {
18675       {
18676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18677       };
18678     } catch (std::exception& e) {
18679       {
18680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18681       };
18682     } catch (Dali::DaliException e) {
18683       {
18684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18685       };
18686     } catch (...) {
18687       {
18688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18689       };
18690     }
18691   }
18692
18693   jresult = result;
18694   return jresult;
18695 }
18696
18697
18698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18699   void * jresult ;
18700   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18701   Dali::RefObject *result = 0 ;
18702
18703   arg1 = (Dali::BaseHandle *)jarg1;
18704   {
18705     try {
18706       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18707     } catch (std::out_of_range& e) {
18708       {
18709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (std::exception& e) {
18712       {
18713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (Dali::DaliException e) {
18716       {
18717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18718       };
18719     } catch (...) {
18720       {
18721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18722       };
18723     }
18724   }
18725
18726   jresult = (void *)result;
18727   return jresult;
18728 }
18729
18730
18731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18732   unsigned int jresult ;
18733   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18734   bool result;
18735
18736   arg1 = (Dali::BaseHandle *)jarg1;
18737   {
18738     try {
18739       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18740     } catch (std::out_of_range& e) {
18741       {
18742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18743       };
18744     } catch (std::exception& e) {
18745       {
18746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18747       };
18748     } catch (Dali::DaliException e) {
18749       {
18750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18751       };
18752     } catch (...) {
18753       {
18754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18755       };
18756     }
18757   }
18758
18759   jresult = result;
18760   return jresult;
18761 }
18762
18763
18764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18765   unsigned int jresult ;
18766   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18767   Dali::BaseHandle *arg2 = 0 ;
18768   bool result;
18769
18770   arg1 = (Dali::BaseHandle *)jarg1;
18771   arg2 = (Dali::BaseHandle *)jarg2;
18772   if (!arg2) {
18773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18774     return 0;
18775   }
18776   {
18777     try {
18778       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18779     } catch (std::out_of_range& e) {
18780       {
18781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18782       };
18783     } catch (std::exception& e) {
18784       {
18785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (Dali::DaliException e) {
18788       {
18789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18790       };
18791     } catch (...) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18794       };
18795     }
18796   }
18797
18798   jresult = result;
18799   return jresult;
18800 }
18801
18802
18803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18804   unsigned int jresult ;
18805   Dali::BaseHandle *arg1 = 0 ;
18806   Dali::BaseHandle *arg2 = 0 ;
18807   bool result;
18808
18809   arg1 = (Dali::BaseHandle *)jarg1;
18810   if (!arg1) {
18811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18812     return 0;
18813   }
18814   arg2 = (Dali::BaseHandle *)jarg2;
18815   if (!arg2) {
18816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18817     return 0;
18818   }
18819   {
18820     try {
18821       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18822     } catch (std::out_of_range& e) {
18823       {
18824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18825       };
18826     } catch (std::exception& e) {
18827       {
18828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18829       };
18830     } catch (Dali::DaliException e) {
18831       {
18832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18833       };
18834     } catch (...) {
18835       {
18836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18837       };
18838     }
18839   }
18840
18841   jresult = result;
18842   return jresult;
18843 }
18844
18845
18846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18847   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18848
18849   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18850   {
18851     try {
18852       delete arg1;
18853     } catch (std::out_of_range& e) {
18854       {
18855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18856       };
18857     } catch (std::exception& e) {
18858       {
18859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18860       };
18861     } catch (Dali::DaliException e) {
18862       {
18863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18864       };
18865     } catch (...) {
18866       {
18867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18868       };
18869     }
18870   }
18871
18872 }
18873
18874
18875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18876   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18877   SlotObserver *arg2 = (SlotObserver *) 0 ;
18878   CallbackBase *arg3 = (CallbackBase *) 0 ;
18879
18880   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18881   arg2 = (SlotObserver *)jarg2;
18882   arg3 = (CallbackBase *)jarg3;
18883   {
18884     try {
18885       (arg1)->SignalConnected(arg2,arg3);
18886     } catch (std::out_of_range& e) {
18887       {
18888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18889       };
18890     } catch (std::exception& e) {
18891       {
18892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18893       };
18894     } catch (Dali::DaliException e) {
18895       {
18896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18897       };
18898     } catch (...) {
18899       {
18900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18901       };
18902     }
18903   }
18904
18905 }
18906
18907
18908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18909   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18910
18911   arg1 = (Dali::SignalObserver *)jarg1;
18912   {
18913     try {
18914       delete arg1;
18915     } catch (std::out_of_range& e) {
18916       {
18917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18918       };
18919     } catch (std::exception& e) {
18920       {
18921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18922       };
18923     } catch (Dali::DaliException e) {
18924       {
18925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18926       };
18927     } catch (...) {
18928       {
18929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18930       };
18931     }
18932   }
18933
18934 }
18935
18936
18937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18938   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18939   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18940   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18941
18942   arg1 = (Dali::SignalObserver *)jarg1;
18943   arg2 = (Dali::SlotObserver *)jarg2;
18944   arg3 = (Dali::CallbackBase *)jarg3;
18945   {
18946     try {
18947       (arg1)->SignalDisconnected(arg2,arg3);
18948     } catch (std::out_of_range& e) {
18949       {
18950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18951       };
18952     } catch (std::exception& e) {
18953       {
18954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18955       };
18956     } catch (Dali::DaliException e) {
18957       {
18958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18959       };
18960     } catch (...) {
18961       {
18962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18963       };
18964     }
18965   }
18966
18967 }
18968
18969
18970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18971   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18972
18973   arg1 = (Dali::SlotObserver *)jarg1;
18974   {
18975     try {
18976       delete arg1;
18977     } catch (std::out_of_range& e) {
18978       {
18979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18980       };
18981     } catch (std::exception& e) {
18982       {
18983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18984       };
18985     } catch (Dali::DaliException e) {
18986       {
18987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18988       };
18989     } catch (...) {
18990       {
18991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18992       };
18993     }
18994   }
18995
18996 }
18997
18998
18999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19000   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19001   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19002
19003   arg1 = (Dali::SlotObserver *)jarg1;
19004   arg2 = (Dali::CallbackBase *)jarg2;
19005   {
19006     try {
19007       (arg1)->SlotDisconnected(arg2);
19008     } catch (std::out_of_range& e) {
19009       {
19010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19011       };
19012     } catch (std::exception& e) {
19013       {
19014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19015       };
19016     } catch (Dali::DaliException e) {
19017       {
19018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19019       };
19020     } catch (...) {
19021       {
19022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19023       };
19024     }
19025   }
19026
19027 }
19028
19029
19030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19031   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19032
19033   arg1 = (Dali::ConnectionTracker *)jarg1;
19034   {
19035     try {
19036       delete arg1;
19037     } catch (std::out_of_range& e) {
19038       {
19039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19040       };
19041     } catch (std::exception& e) {
19042       {
19043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19044       };
19045     } catch (Dali::DaliException e) {
19046       {
19047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19048       };
19049     } catch (...) {
19050       {
19051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19052       };
19053     }
19054   }
19055
19056 }
19057
19058
19059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19060   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19061
19062   arg1 = (Dali::ConnectionTracker *)jarg1;
19063   {
19064     try {
19065       (arg1)->DisconnectAll();
19066     } catch (std::out_of_range& e) {
19067       {
19068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19069       };
19070     } catch (std::exception& e) {
19071       {
19072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19073       };
19074     } catch (Dali::DaliException e) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19077       };
19078     } catch (...) {
19079       {
19080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19081       };
19082     }
19083   }
19084
19085 }
19086
19087
19088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19089   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19090   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19091   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19092
19093   arg1 = (Dali::ConnectionTracker *)jarg1;
19094   arg2 = (Dali::SlotObserver *)jarg2;
19095   arg3 = (Dali::CallbackBase *)jarg3;
19096   {
19097     try {
19098       (arg1)->SignalConnected(arg2,arg3);
19099     } catch (std::out_of_range& e) {
19100       {
19101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19102       };
19103     } catch (std::exception& e) {
19104       {
19105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19106       };
19107     } catch (Dali::DaliException e) {
19108       {
19109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19110       };
19111     } catch (...) {
19112       {
19113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19114       };
19115     }
19116   }
19117
19118 }
19119
19120
19121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19122   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19123   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19124   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19125
19126   arg1 = (Dali::ConnectionTracker *)jarg1;
19127   arg2 = (Dali::SlotObserver *)jarg2;
19128   arg3 = (Dali::CallbackBase *)jarg3;
19129   {
19130     try {
19131       (arg1)->SignalDisconnected(arg2,arg3);
19132     } catch (std::out_of_range& e) {
19133       {
19134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19135       };
19136     } catch (std::exception& e) {
19137       {
19138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19139       };
19140     } catch (Dali::DaliException e) {
19141       {
19142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19143       };
19144     } catch (...) {
19145       {
19146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19147       };
19148     }
19149   }
19150
19151 }
19152
19153
19154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19155   unsigned long jresult ;
19156   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19157   std::size_t result;
19158
19159   arg1 = (Dali::ConnectionTracker *)jarg1;
19160   {
19161     try {
19162       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19163     } catch (std::out_of_range& e) {
19164       {
19165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19166       };
19167     } catch (std::exception& e) {
19168       {
19169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19170       };
19171     } catch (Dali::DaliException e) {
19172       {
19173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19174       };
19175     } catch (...) {
19176       {
19177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19178       };
19179     }
19180   }
19181
19182   jresult = (unsigned long)result;
19183   return jresult;
19184 }
19185
19186
19187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19188   void * jresult ;
19189   Dali::ObjectRegistry *result = 0 ;
19190
19191   {
19192     try {
19193       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19194     } catch (std::out_of_range& e) {
19195       {
19196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (std::exception& e) {
19199       {
19200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19201       };
19202     } catch (Dali::DaliException e) {
19203       {
19204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19205       };
19206     } catch (...) {
19207       {
19208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19209       };
19210     }
19211   }
19212
19213   jresult = (void *)result;
19214   return jresult;
19215 }
19216
19217
19218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19219   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19220
19221   arg1 = (Dali::ObjectRegistry *)jarg1;
19222   {
19223     try {
19224       delete arg1;
19225     } catch (std::out_of_range& e) {
19226       {
19227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19228       };
19229     } catch (std::exception& e) {
19230       {
19231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19232       };
19233     } catch (Dali::DaliException e) {
19234       {
19235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19240       };
19241     }
19242   }
19243
19244 }
19245
19246
19247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19248   void * jresult ;
19249   Dali::ObjectRegistry *arg1 = 0 ;
19250   Dali::ObjectRegistry *result = 0 ;
19251
19252   arg1 = (Dali::ObjectRegistry *)jarg1;
19253   if (!arg1) {
19254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19255     return 0;
19256   }
19257   {
19258     try {
19259       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19260     } catch (std::out_of_range& e) {
19261       {
19262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19263       };
19264     } catch (std::exception& e) {
19265       {
19266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19267       };
19268     } catch (Dali::DaliException e) {
19269       {
19270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19271       };
19272     } catch (...) {
19273       {
19274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19275       };
19276     }
19277   }
19278
19279   jresult = (void *)result;
19280   return jresult;
19281 }
19282
19283
19284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19285   void * jresult ;
19286   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19287   Dali::ObjectRegistry *arg2 = 0 ;
19288   Dali::ObjectRegistry *result = 0 ;
19289
19290   arg1 = (Dali::ObjectRegistry *)jarg1;
19291   arg2 = (Dali::ObjectRegistry *)jarg2;
19292   if (!arg2) {
19293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19294     return 0;
19295   }
19296   {
19297     try {
19298       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19299     } catch (std::out_of_range& e) {
19300       {
19301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19302       };
19303     } catch (std::exception& e) {
19304       {
19305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19306       };
19307     } catch (Dali::DaliException e) {
19308       {
19309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19310       };
19311     } catch (...) {
19312       {
19313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19314       };
19315     }
19316   }
19317
19318   jresult = (void *)result;
19319   return jresult;
19320 }
19321
19322
19323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19324   void * jresult ;
19325   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19326   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19327
19328   arg1 = (Dali::ObjectRegistry *)jarg1;
19329   {
19330     try {
19331       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19332     } catch (std::out_of_range& e) {
19333       {
19334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19335       };
19336     } catch (std::exception& e) {
19337       {
19338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (Dali::DaliException e) {
19341       {
19342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19343       };
19344     } catch (...) {
19345       {
19346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19347       };
19348     }
19349   }
19350
19351   jresult = (void *)result;
19352   return jresult;
19353 }
19354
19355
19356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19357   void * jresult ;
19358   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19359   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19360
19361   arg1 = (Dali::ObjectRegistry *)jarg1;
19362   {
19363     try {
19364       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19365     } catch (std::out_of_range& e) {
19366       {
19367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19368       };
19369     } catch (std::exception& e) {
19370       {
19371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19372       };
19373     } catch (Dali::DaliException e) {
19374       {
19375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19376       };
19377     } catch (...) {
19378       {
19379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19380       };
19381     }
19382   }
19383
19384   jresult = (void *)result;
19385   return jresult;
19386 }
19387
19388
19389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19390   void * jresult ;
19391   Dali::PropertyCondition *result = 0 ;
19392
19393   {
19394     try {
19395       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19396     } catch (std::out_of_range& e) {
19397       {
19398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (std::exception& e) {
19401       {
19402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19403       };
19404     } catch (Dali::DaliException e) {
19405       {
19406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19407       };
19408     } catch (...) {
19409       {
19410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19411       };
19412     }
19413   }
19414
19415   jresult = (void *)result;
19416   return jresult;
19417 }
19418
19419
19420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19421   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19422
19423   arg1 = (Dali::PropertyCondition *)jarg1;
19424   {
19425     try {
19426       delete arg1;
19427     } catch (std::out_of_range& e) {
19428       {
19429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19430       };
19431     } catch (std::exception& e) {
19432       {
19433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19434       };
19435     } catch (Dali::DaliException e) {
19436       {
19437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19438       };
19439     } catch (...) {
19440       {
19441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19442       };
19443     }
19444   }
19445
19446 }
19447
19448
19449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19450   void * jresult ;
19451   Dali::PropertyCondition *arg1 = 0 ;
19452   Dali::PropertyCondition *result = 0 ;
19453
19454   arg1 = (Dali::PropertyCondition *)jarg1;
19455   if (!arg1) {
19456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19457     return 0;
19458   }
19459   {
19460     try {
19461       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19462     } catch (std::out_of_range& e) {
19463       {
19464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19465       };
19466     } catch (std::exception& e) {
19467       {
19468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19469       };
19470     } catch (Dali::DaliException e) {
19471       {
19472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19473       };
19474     } catch (...) {
19475       {
19476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19477       };
19478     }
19479   }
19480
19481   jresult = (void *)result;
19482   return jresult;
19483 }
19484
19485
19486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19487   void * jresult ;
19488   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19489   Dali::PropertyCondition *arg2 = 0 ;
19490   Dali::PropertyCondition *result = 0 ;
19491
19492   arg1 = (Dali::PropertyCondition *)jarg1;
19493   arg2 = (Dali::PropertyCondition *)jarg2;
19494   if (!arg2) {
19495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19496     return 0;
19497   }
19498   {
19499     try {
19500       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19501     } catch (std::out_of_range& e) {
19502       {
19503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19504       };
19505     } catch (std::exception& e) {
19506       {
19507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19508       };
19509     } catch (Dali::DaliException e) {
19510       {
19511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19512       };
19513     } catch (...) {
19514       {
19515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19516       };
19517     }
19518   }
19519
19520   jresult = (void *)result;
19521   return jresult;
19522 }
19523
19524
19525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19526   unsigned long jresult ;
19527   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19528   std::size_t result;
19529
19530   arg1 = (Dali::PropertyCondition *)jarg1;
19531   {
19532     try {
19533       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19534     } catch (std::out_of_range& e) {
19535       {
19536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19537       };
19538     } catch (std::exception& e) {
19539       {
19540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19541       };
19542     } catch (...) {
19543       {
19544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19545       };
19546     }
19547   }
19548   jresult = (unsigned long)result;
19549   return jresult;
19550 }
19551
19552
19553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19554   float jresult ;
19555   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19556   std::size_t arg2 ;
19557   float result;
19558
19559   arg1 = (Dali::PropertyCondition *)jarg1;
19560   arg2 = (std::size_t)jarg2;
19561   {
19562     try {
19563       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19564     } catch (std::out_of_range& e) {
19565       {
19566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19567       };
19568     } catch (std::exception& e) {
19569       {
19570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19571       };
19572     } catch (...) {
19573       {
19574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19575       };
19576     }
19577   }
19578   jresult = result;
19579   return jresult;
19580 }
19581
19582
19583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19584   void * jresult ;
19585   float arg1 ;
19586   Dali::PropertyCondition result;
19587
19588   arg1 = (float)jarg1;
19589   {
19590     try {
19591       result = Dali::LessThanCondition(arg1);
19592     } catch (std::out_of_range& e) {
19593       {
19594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19595       };
19596     } catch (std::exception& e) {
19597       {
19598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19599       };
19600     } catch (Dali::DaliException e) {
19601       {
19602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19603       };
19604     } catch (...) {
19605       {
19606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19607       };
19608     }
19609   }
19610
19611   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19612   return jresult;
19613 }
19614
19615
19616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19617   void * jresult ;
19618   float arg1 ;
19619   Dali::PropertyCondition result;
19620
19621   arg1 = (float)jarg1;
19622   {
19623     try {
19624       result = Dali::GreaterThanCondition(arg1);
19625     } catch (std::out_of_range& e) {
19626       {
19627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19628       };
19629     } catch (std::exception& e) {
19630       {
19631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19632       };
19633     } catch (Dali::DaliException e) {
19634       {
19635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19636       };
19637     } catch (...) {
19638       {
19639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19640       };
19641     }
19642   }
19643
19644   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19645   return jresult;
19646 }
19647
19648
19649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19650   void * jresult ;
19651   float arg1 ;
19652   float arg2 ;
19653   Dali::PropertyCondition result;
19654
19655   arg1 = (float)jarg1;
19656   arg2 = (float)jarg2;
19657   {
19658     try {
19659       result = Dali::InsideCondition(arg1,arg2);
19660     } catch (std::out_of_range& e) {
19661       {
19662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19663       };
19664     } catch (std::exception& e) {
19665       {
19666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (Dali::DaliException e) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19671       };
19672     } catch (...) {
19673       {
19674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19675       };
19676     }
19677   }
19678
19679   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19680   return jresult;
19681 }
19682
19683
19684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19685   void * jresult ;
19686   float arg1 ;
19687   float arg2 ;
19688   Dali::PropertyCondition result;
19689
19690   arg1 = (float)jarg1;
19691   arg2 = (float)jarg2;
19692   {
19693     try {
19694       result = Dali::OutsideCondition(arg1,arg2);
19695     } catch (std::out_of_range& e) {
19696       {
19697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19698       };
19699     } catch (std::exception& e) {
19700       {
19701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19702       };
19703     } catch (Dali::DaliException e) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19706       };
19707     } catch (...) {
19708       {
19709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19710       };
19711     }
19712   }
19713
19714   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19715   return jresult;
19716 }
19717
19718
19719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19720   void * jresult ;
19721   float arg1 ;
19722   float arg2 ;
19723   Dali::PropertyCondition result;
19724
19725   arg1 = (float)jarg1;
19726   arg2 = (float)jarg2;
19727   {
19728     try {
19729       result = Dali::StepCondition(arg1,arg2);
19730     } catch (std::out_of_range& e) {
19731       {
19732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (std::exception& e) {
19735       {
19736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19737       };
19738     } catch (Dali::DaliException e) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19741       };
19742     } catch (...) {
19743       {
19744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19745       };
19746     }
19747   }
19748
19749   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19750   return jresult;
19751 }
19752
19753
19754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19755   void * jresult ;
19756   float arg1 ;
19757   Dali::PropertyCondition result;
19758
19759   arg1 = (float)jarg1;
19760   {
19761     try {
19762       result = Dali::StepCondition(arg1);
19763     } catch (std::out_of_range& e) {
19764       {
19765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19766       };
19767     } catch (std::exception& e) {
19768       {
19769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19770       };
19771     } catch (Dali::DaliException e) {
19772       {
19773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19774       };
19775     } catch (...) {
19776       {
19777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19778       };
19779     }
19780   }
19781
19782   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19783   return jresult;
19784 }
19785
19786
19787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19788   void * jresult ;
19789   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19790   Dali::PropertyCondition result;
19791
19792   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19793   if (!arg1) {
19794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19795     return 0;
19796   }
19797   {
19798     try {
19799       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19800     } catch (std::out_of_range& e) {
19801       {
19802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19803       };
19804     } catch (std::exception& e) {
19805       {
19806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19807       };
19808     } catch (Dali::DaliException e) {
19809       {
19810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19811       };
19812     } catch (...) {
19813       {
19814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19815       };
19816     }
19817   }
19818
19819   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19820   return jresult;
19821 }
19822
19823
19824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19825   void * jresult ;
19826   Dali::PropertyNotification *result = 0 ;
19827
19828   {
19829     try {
19830       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19831     } catch (std::out_of_range& e) {
19832       {
19833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19834       };
19835     } catch (std::exception& e) {
19836       {
19837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19838       };
19839     } catch (Dali::DaliException e) {
19840       {
19841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19842       };
19843     } catch (...) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19846       };
19847     }
19848   }
19849
19850   jresult = (void *)result;
19851   return jresult;
19852 }
19853
19854
19855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19856   void * jresult ;
19857   Dali::BaseHandle arg1 ;
19858   Dali::BaseHandle *argp1 ;
19859   Dali::PropertyNotification result;
19860
19861   argp1 = (Dali::BaseHandle *)jarg1;
19862   if (!argp1) {
19863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19864     return 0;
19865   }
19866   arg1 = *argp1;
19867   {
19868     try {
19869       result = Dali::PropertyNotification::DownCast(arg1);
19870     } catch (std::out_of_range& e) {
19871       {
19872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (std::exception& e) {
19875       {
19876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19877       };
19878     } catch (Dali::DaliException e) {
19879       {
19880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19881       };
19882     } catch (...) {
19883       {
19884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19885       };
19886     }
19887   }
19888
19889   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19890   return jresult;
19891 }
19892
19893
19894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19895   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19896
19897   arg1 = (Dali::PropertyNotification *)jarg1;
19898   {
19899     try {
19900       delete arg1;
19901     } catch (std::out_of_range& e) {
19902       {
19903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19904       };
19905     } catch (std::exception& e) {
19906       {
19907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19908       };
19909     } catch (Dali::DaliException e) {
19910       {
19911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19912       };
19913     } catch (...) {
19914       {
19915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19916       };
19917     }
19918   }
19919
19920 }
19921
19922
19923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19924   void * jresult ;
19925   Dali::PropertyNotification *arg1 = 0 ;
19926   Dali::PropertyNotification *result = 0 ;
19927
19928   arg1 = (Dali::PropertyNotification *)jarg1;
19929   if (!arg1) {
19930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19931     return 0;
19932   }
19933   {
19934     try {
19935       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19936     } catch (std::out_of_range& e) {
19937       {
19938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (std::exception& e) {
19941       {
19942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19943       };
19944     } catch (Dali::DaliException e) {
19945       {
19946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19947       };
19948     } catch (...) {
19949       {
19950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19951       };
19952     }
19953   }
19954
19955   jresult = (void *)result;
19956   return jresult;
19957 }
19958
19959
19960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19961   void * jresult ;
19962   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19963   Dali::PropertyNotification *arg2 = 0 ;
19964   Dali::PropertyNotification *result = 0 ;
19965
19966   arg1 = (Dali::PropertyNotification *)jarg1;
19967   arg2 = (Dali::PropertyNotification *)jarg2;
19968   if (!arg2) {
19969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19970     return 0;
19971   }
19972   {
19973     try {
19974       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19975     } catch (std::out_of_range& e) {
19976       {
19977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19978       };
19979     } catch (std::exception& e) {
19980       {
19981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19982       };
19983     } catch (Dali::DaliException e) {
19984       {
19985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19986       };
19987     } catch (...) {
19988       {
19989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19990       };
19991     }
19992   }
19993
19994   jresult = (void *)result;
19995   return jresult;
19996 }
19997
19998
19999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20000   void * jresult ;
20001   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20002   Dali::PropertyCondition result;
20003
20004   arg1 = (Dali::PropertyNotification *)jarg1;
20005   {
20006     try {
20007       result = (arg1)->GetCondition();
20008     } catch (std::out_of_range& e) {
20009       {
20010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20011       };
20012     } catch (std::exception& e) {
20013       {
20014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20015       };
20016     } catch (Dali::DaliException e) {
20017       {
20018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20019       };
20020     } catch (...) {
20021       {
20022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20023       };
20024     }
20025   }
20026
20027   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20028   return jresult;
20029 }
20030
20031
20032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20033   void * jresult ;
20034   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20035   Dali::Handle result;
20036
20037   arg1 = (Dali::PropertyNotification *)jarg1;
20038   {
20039     try {
20040       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20041     } catch (std::out_of_range& e) {
20042       {
20043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20044       };
20045     } catch (std::exception& e) {
20046       {
20047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20048       };
20049     } catch (Dali::DaliException e) {
20050       {
20051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20052       };
20053     } catch (...) {
20054       {
20055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20056       };
20057     }
20058   }
20059
20060   jresult = new Dali::Handle((const Dali::Handle &)result);
20061   return jresult;
20062 }
20063
20064
20065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20066   int jresult ;
20067   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20068   Dali::Property::Index result;
20069
20070   arg1 = (Dali::PropertyNotification *)jarg1;
20071   {
20072     try {
20073       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20074     } catch (std::out_of_range& e) {
20075       {
20076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20077       };
20078     } catch (std::exception& e) {
20079       {
20080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20081       };
20082     } catch (Dali::DaliException e) {
20083       {
20084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20085       };
20086     } catch (...) {
20087       {
20088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20089       };
20090     }
20091   }
20092
20093   jresult = result;
20094   return jresult;
20095 }
20096
20097
20098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20099   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20100   Dali::PropertyNotification::NotifyMode arg2 ;
20101
20102   arg1 = (Dali::PropertyNotification *)jarg1;
20103   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20104   {
20105     try {
20106       (arg1)->SetNotifyMode(arg2);
20107     } catch (std::out_of_range& e) {
20108       {
20109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20110       };
20111     } catch (std::exception& e) {
20112       {
20113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20114       };
20115     } catch (Dali::DaliException e) {
20116       {
20117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20118       };
20119     } catch (...) {
20120       {
20121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20122       };
20123     }
20124   }
20125
20126 }
20127
20128
20129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20130   int jresult ;
20131   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20132   Dali::PropertyNotification::NotifyMode result;
20133
20134   arg1 = (Dali::PropertyNotification *)jarg1;
20135   {
20136     try {
20137       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20138     } catch (std::out_of_range& e) {
20139       {
20140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20141       };
20142     } catch (std::exception& e) {
20143       {
20144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20145       };
20146     } catch (Dali::DaliException e) {
20147       {
20148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20149       };
20150     } catch (...) {
20151       {
20152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20153       };
20154     }
20155   }
20156
20157   jresult = (int)result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20163   unsigned int jresult ;
20164   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20165   bool result;
20166
20167   arg1 = (Dali::PropertyNotification *)jarg1;
20168   {
20169     try {
20170       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20171     } catch (std::out_of_range& e) {
20172       {
20173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20174       };
20175     } catch (std::exception& e) {
20176       {
20177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20178       };
20179     } catch (Dali::DaliException e) {
20180       {
20181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20182       };
20183     } catch (...) {
20184       {
20185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20186       };
20187     }
20188   }
20189
20190   jresult = result;
20191   return jresult;
20192 }
20193
20194
20195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20196   void * jresult ;
20197   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20198   Dali::PropertyNotifySignalType *result = 0 ;
20199
20200   arg1 = (Dali::PropertyNotification *)jarg1;
20201   {
20202     try {
20203       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20204     } catch (std::out_of_range& e) {
20205       {
20206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20207       };
20208     } catch (std::exception& e) {
20209       {
20210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20211       };
20212     } catch (Dali::DaliException e) {
20213       {
20214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20215       };
20216     } catch (...) {
20217       {
20218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20219       };
20220     }
20221   }
20222
20223   jresult = (void *)result;
20224   return jresult;
20225 }
20226
20227
20228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20229   void * jresult ;
20230   Dali::Handle *result = 0 ;
20231
20232   {
20233     try {
20234       result = (Dali::Handle *)new Dali::Handle();
20235     } catch (std::out_of_range& e) {
20236       {
20237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20238       };
20239     } catch (std::exception& e) {
20240       {
20241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20242       };
20243     } catch (Dali::DaliException e) {
20244       {
20245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20246       };
20247     } catch (...) {
20248       {
20249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20250       };
20251     }
20252   }
20253
20254   jresult = (void *)result;
20255   return jresult;
20256 }
20257
20258
20259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20260   void * jresult ;
20261   Dali::Handle result;
20262
20263   {
20264     try {
20265       result = Dali::Handle::New();
20266     } catch (std::out_of_range& e) {
20267       {
20268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20269       };
20270     } catch (std::exception& e) {
20271       {
20272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20273       };
20274     } catch (Dali::DaliException e) {
20275       {
20276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20277       };
20278     } catch (...) {
20279       {
20280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20281       };
20282     }
20283   }
20284
20285   jresult = new Dali::Handle((const Dali::Handle &)result);
20286   return jresult;
20287 }
20288
20289
20290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20291   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20292
20293   arg1 = (Dali::Handle *)jarg1;
20294   {
20295     try {
20296       delete arg1;
20297     } catch (std::out_of_range& e) {
20298       {
20299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20300       };
20301     } catch (std::exception& e) {
20302       {
20303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20304       };
20305     } catch (Dali::DaliException e) {
20306       {
20307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20308       };
20309     } catch (...) {
20310       {
20311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20312       };
20313     }
20314   }
20315
20316 }
20317
20318
20319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20320   void * jresult ;
20321   Dali::Handle *arg1 = 0 ;
20322   Dali::Handle *result = 0 ;
20323
20324   arg1 = (Dali::Handle *)jarg1;
20325   if (!arg1) {
20326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20327     return 0;
20328   }
20329   {
20330     try {
20331       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20332     } catch (std::out_of_range& e) {
20333       {
20334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20335       };
20336     } catch (std::exception& e) {
20337       {
20338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20339       };
20340     } catch (Dali::DaliException e) {
20341       {
20342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20343       };
20344     } catch (...) {
20345       {
20346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20347       };
20348     }
20349   }
20350
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20357   void * jresult ;
20358   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20359   Dali::Handle *arg2 = 0 ;
20360   Dali::Handle *result = 0 ;
20361
20362   arg1 = (Dali::Handle *)jarg1;
20363   arg2 = (Dali::Handle *)jarg2;
20364   if (!arg2) {
20365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20366     return 0;
20367   }
20368   {
20369     try {
20370       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20371     } catch (std::out_of_range& e) {
20372       {
20373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20374       };
20375     } catch (std::exception& e) {
20376       {
20377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20378       };
20379     } catch (Dali::DaliException e) {
20380       {
20381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20382       };
20383     } catch (...) {
20384       {
20385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20386       };
20387     }
20388   }
20389
20390   jresult = (void *)result;
20391   return jresult;
20392 }
20393
20394
20395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20396   void * jresult ;
20397   Dali::BaseHandle arg1 ;
20398   Dali::BaseHandle *argp1 ;
20399   Dali::Handle result;
20400
20401   argp1 = (Dali::BaseHandle *)jarg1;
20402   if (!argp1) {
20403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20404     return 0;
20405   }
20406   arg1 = *argp1;
20407   {
20408     try {
20409       result = Dali::Handle::DownCast(arg1);
20410     } catch (std::out_of_range& e) {
20411       {
20412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20413       };
20414     } catch (std::exception& e) {
20415       {
20416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20417       };
20418     } catch (Dali::DaliException e) {
20419       {
20420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20421       };
20422     } catch (...) {
20423       {
20424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20425       };
20426     }
20427   }
20428
20429   jresult = new Dali::Handle((const Dali::Handle &)result);
20430   return jresult;
20431 }
20432
20433
20434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20435   unsigned int jresult ;
20436   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20437   Dali::Handle::Capability arg2 ;
20438   bool result;
20439
20440   arg1 = (Dali::Handle *)jarg1;
20441   arg2 = (Dali::Handle::Capability)jarg2;
20442   {
20443     try {
20444       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20445     } catch (std::out_of_range& e) {
20446       {
20447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20448       };
20449     } catch (std::exception& e) {
20450       {
20451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20452       };
20453     } catch (Dali::DaliException e) {
20454       {
20455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20456       };
20457     } catch (...) {
20458       {
20459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20460       };
20461     }
20462   }
20463
20464   jresult = result;
20465   return jresult;
20466 }
20467
20468
20469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20470   unsigned int jresult ;
20471   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20472   unsigned int result;
20473
20474   arg1 = (Dali::Handle *)jarg1;
20475   {
20476     try {
20477       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20478     } catch (std::out_of_range& e) {
20479       {
20480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20481       };
20482     } catch (std::exception& e) {
20483       {
20484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20485       };
20486     } catch (Dali::DaliException e) {
20487       {
20488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20489       };
20490     } catch (...) {
20491       {
20492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20493       };
20494     }
20495   }
20496
20497   jresult = result;
20498   return jresult;
20499 }
20500
20501
20502 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20503   char * jresult ;
20504   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20505   Dali::Property::Index arg2 ;
20506   std::string result;
20507
20508   arg1 = (Dali::Handle *)jarg1;
20509   arg2 = (Dali::Property::Index)jarg2;
20510   {
20511     try {
20512       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20513     } catch (std::out_of_range& e) {
20514       {
20515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20516       };
20517     } catch (std::exception& e) {
20518       {
20519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20520       };
20521     } catch (Dali::DaliException e) {
20522       {
20523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20524       };
20525     } catch (...) {
20526       {
20527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20528       };
20529     }
20530   }
20531
20532   jresult = SWIG_csharp_string_callback((&result)->c_str());
20533   return jresult;
20534 }
20535
20536
20537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20538   int jresult ;
20539   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20540   std::string *arg2 = 0 ;
20541   Dali::Property::Index result;
20542
20543   arg1 = (Dali::Handle *)jarg1;
20544   if (!jarg2) {
20545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20546     return 0;
20547   }
20548   std::string arg2_str(jarg2);
20549   arg2 = &arg2_str;
20550   {
20551     try {
20552       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20553     } catch (std::out_of_range& e) {
20554       {
20555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20556       };
20557     } catch (std::exception& e) {
20558       {
20559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20560       };
20561     } catch (Dali::DaliException e) {
20562       {
20563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20564       };
20565     } catch (...) {
20566       {
20567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20568       };
20569     }
20570   }
20571
20572   jresult = result;
20573
20574   //argout typemap for const std::string&
20575
20576   return jresult;
20577 }
20578
20579
20580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20581   unsigned int jresult ;
20582   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20583   Dali::Property::Index arg2 ;
20584   bool result;
20585
20586   arg1 = (Dali::Handle *)jarg1;
20587   arg2 = (Dali::Property::Index)jarg2;
20588   {
20589     try {
20590       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20591     } catch (std::out_of_range& e) {
20592       {
20593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20594       };
20595     } catch (std::exception& e) {
20596       {
20597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20598       };
20599     } catch (Dali::DaliException e) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20602       };
20603     } catch (...) {
20604       {
20605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20606       };
20607     }
20608   }
20609
20610   jresult = result;
20611   return jresult;
20612 }
20613
20614
20615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20616   unsigned int jresult ;
20617   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20618   Dali::Property::Index arg2 ;
20619   bool result;
20620
20621   arg1 = (Dali::Handle *)jarg1;
20622   arg2 = (Dali::Property::Index)jarg2;
20623   {
20624     try {
20625       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20626     } catch (std::out_of_range& e) {
20627       {
20628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20629       };
20630     } catch (std::exception& e) {
20631       {
20632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20633       };
20634     } catch (Dali::DaliException e) {
20635       {
20636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20637       };
20638     } catch (...) {
20639       {
20640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20641       };
20642     }
20643   }
20644
20645   jresult = result;
20646   return jresult;
20647 }
20648
20649
20650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20651   unsigned int jresult ;
20652   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20653   Dali::Property::Index arg2 ;
20654   bool result;
20655
20656   arg1 = (Dali::Handle *)jarg1;
20657   arg2 = (Dali::Property::Index)jarg2;
20658   {
20659     try {
20660       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20661     } catch (std::out_of_range& e) {
20662       {
20663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20664       };
20665     } catch (std::exception& e) {
20666       {
20667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (Dali::DaliException e) {
20670       {
20671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679
20680   jresult = result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20686   int jresult ;
20687   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20688   Dali::Property::Index arg2 ;
20689   Dali::Property::Type result;
20690
20691   arg1 = (Dali::Handle *)jarg1;
20692   arg2 = (Dali::Property::Index)jarg2;
20693   {
20694     try {
20695       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20696     } catch (std::out_of_range& e) {
20697       {
20698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (std::exception& e) {
20701       {
20702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20703       };
20704     } catch (Dali::DaliException e) {
20705       {
20706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20707       };
20708     } catch (...) {
20709       {
20710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20711       };
20712     }
20713   }
20714
20715   jresult = (int)result;
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20721   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20722   Dali::Property::Index arg2 ;
20723   Dali::Property::Value *arg3 = 0 ;
20724
20725   arg1 = (Dali::Handle *)jarg1;
20726   arg2 = (Dali::Property::Index)jarg2;
20727   arg3 = (Dali::Property::Value *)jarg3;
20728   if (!arg3) {
20729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20730     return ;
20731   }
20732   {
20733     try {
20734       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20735     } catch (std::out_of_range& e) {
20736       {
20737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20738       };
20739     } catch (std::exception& e) {
20740       {
20741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20742       };
20743     } catch (Dali::DaliException e) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20746       };
20747     } catch (...) {
20748       {
20749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20750       };
20751     }
20752   }
20753
20754 }
20755
20756
20757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20758   int jresult ;
20759   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20760   std::string *arg2 = 0 ;
20761   Dali::Property::Value *arg3 = 0 ;
20762   Dali::Property::Index result;
20763
20764   arg1 = (Dali::Handle *)jarg1;
20765   if (!jarg2) {
20766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20767     return 0;
20768   }
20769   std::string arg2_str(jarg2);
20770   arg2 = &arg2_str;
20771   arg3 = (Dali::Property::Value *)jarg3;
20772   if (!arg3) {
20773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20774     return 0;
20775   }
20776   {
20777     try {
20778       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20779     } catch (std::out_of_range& e) {
20780       {
20781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20782       };
20783     } catch (std::exception& e) {
20784       {
20785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20786       };
20787     } catch (Dali::DaliException e) {
20788       {
20789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20790       };
20791     } catch (...) {
20792       {
20793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20794       };
20795     }
20796   }
20797
20798   jresult = result;
20799
20800   //argout typemap for const std::string&
20801
20802   return jresult;
20803 }
20804
20805
20806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20807   int jresult ;
20808   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20809   std::string *arg2 = 0 ;
20810   Dali::Property::Value *arg3 = 0 ;
20811   Dali::Property::AccessMode arg4 ;
20812   Dali::Property::Index result;
20813
20814   arg1 = (Dali::Handle *)jarg1;
20815   if (!jarg2) {
20816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20817     return 0;
20818   }
20819   std::string arg2_str(jarg2);
20820   arg2 = &arg2_str;
20821   arg3 = (Dali::Property::Value *)jarg3;
20822   if (!arg3) {
20823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20824     return 0;
20825   }
20826   arg4 = (Dali::Property::AccessMode)jarg4;
20827   {
20828     try {
20829       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20830     } catch (std::out_of_range& e) {
20831       {
20832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20833       };
20834     } catch (std::exception& e) {
20835       {
20836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20837       };
20838     } catch (Dali::DaliException e) {
20839       {
20840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20841       };
20842     } catch (...) {
20843       {
20844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20845       };
20846     }
20847   }
20848
20849   jresult = result;
20850
20851   //argout typemap for const std::string&
20852
20853   return jresult;
20854 }
20855
20856
20857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20858   void * jresult ;
20859   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20860   Dali::Property::Index arg2 ;
20861   Dali::Property::Value result;
20862
20863   arg1 = (Dali::Handle *)jarg1;
20864   arg2 = (Dali::Property::Index)jarg2;
20865   {
20866     try {
20867       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20868     } catch (std::out_of_range& e) {
20869       {
20870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (std::exception& e) {
20873       {
20874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20875       };
20876     } catch (Dali::DaliException e) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20879       };
20880     } catch (...) {
20881       {
20882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20883       };
20884     }
20885   }
20886
20887   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20888   return jresult;
20889 }
20890
20891
20892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20893   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20894   Dali::Property::IndexContainer *arg2 = 0 ;
20895
20896   arg1 = (Dali::Handle *)jarg1;
20897   arg2 = (Dali::Property::IndexContainer *)jarg2;
20898   if (!arg2) {
20899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20900     return ;
20901   }
20902   {
20903     try {
20904       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20905     } catch (std::out_of_range& e) {
20906       {
20907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20908       };
20909     } catch (std::exception& e) {
20910       {
20911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20912       };
20913     } catch (Dali::DaliException e) {
20914       {
20915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20916       };
20917     } catch (...) {
20918       {
20919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20920       };
20921     }
20922   }
20923
20924 }
20925
20926
20927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20928   void * jresult ;
20929   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20930   Dali::Property::Index arg2 ;
20931   Dali::PropertyCondition *arg3 = 0 ;
20932   Dali::PropertyNotification result;
20933
20934   arg1 = (Dali::Handle *)jarg1;
20935   arg2 = (Dali::Property::Index)jarg2;
20936   arg3 = (Dali::PropertyCondition *)jarg3;
20937   if (!arg3) {
20938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20939     return 0;
20940   }
20941   {
20942     try {
20943       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20944     } catch (std::out_of_range& e) {
20945       {
20946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20947       };
20948     } catch (std::exception& e) {
20949       {
20950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20951       };
20952     } catch (Dali::DaliException e) {
20953       {
20954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20955       };
20956     } catch (...) {
20957       {
20958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20959       };
20960     }
20961   }
20962
20963   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20964   return jresult;
20965 }
20966
20967
20968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20969   void * jresult ;
20970   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20971   Dali::Property::Index arg2 ;
20972   int arg3 ;
20973   Dali::PropertyCondition *arg4 = 0 ;
20974   Dali::PropertyNotification result;
20975
20976   arg1 = (Dali::Handle *)jarg1;
20977   arg2 = (Dali::Property::Index)jarg2;
20978   arg3 = (int)jarg3;
20979   arg4 = (Dali::PropertyCondition *)jarg4;
20980   if (!arg4) {
20981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20982     return 0;
20983   }
20984   {
20985     try {
20986       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20987     } catch (std::out_of_range& e) {
20988       {
20989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (std::exception& e) {
20992       {
20993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20994       };
20995     } catch (Dali::DaliException e) {
20996       {
20997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20998       };
20999     } catch (...) {
21000       {
21001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21002       };
21003     }
21004   }
21005
21006   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21007   return jresult;
21008 }
21009
21010
21011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21012   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21013   Dali::PropertyNotification arg2 ;
21014   Dali::PropertyNotification *argp2 ;
21015
21016   arg1 = (Dali::Handle *)jarg1;
21017   argp2 = (Dali::PropertyNotification *)jarg2;
21018   if (!argp2) {
21019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21020     return ;
21021   }
21022   arg2 = *argp2;
21023   {
21024     try {
21025       (arg1)->RemovePropertyNotification(arg2);
21026     } catch (std::out_of_range& e) {
21027       {
21028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21029       };
21030     } catch (std::exception& e) {
21031       {
21032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21033       };
21034     } catch (Dali::DaliException e) {
21035       {
21036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21037       };
21038     } catch (...) {
21039       {
21040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21041       };
21042     }
21043   }
21044
21045 }
21046
21047
21048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21049   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21050
21051   arg1 = (Dali::Handle *)jarg1;
21052   {
21053     try {
21054       (arg1)->RemovePropertyNotifications();
21055     } catch (std::out_of_range& e) {
21056       {
21057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21058       };
21059     } catch (std::exception& e) {
21060       {
21061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21062       };
21063     } catch (Dali::DaliException e) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21066       };
21067     } catch (...) {
21068       {
21069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21070       };
21071     }
21072   }
21073
21074 }
21075
21076
21077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21078   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21079
21080   arg1 = (Dali::Handle *)jarg1;
21081   {
21082     try {
21083       (arg1)->RemoveConstraints();
21084     } catch (std::out_of_range& e) {
21085       {
21086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21087       };
21088     } catch (std::exception& e) {
21089       {
21090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21091       };
21092     } catch (Dali::DaliException e) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21095       };
21096     } catch (...) {
21097       {
21098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21099       };
21100     }
21101   }
21102
21103 }
21104
21105
21106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21107   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21108   unsigned int arg2 ;
21109
21110   arg1 = (Dali::Handle *)jarg1;
21111   arg2 = (unsigned int)jarg2;
21112   {
21113     try {
21114       (arg1)->RemoveConstraints(arg2);
21115     } catch (std::out_of_range& e) {
21116       {
21117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21118       };
21119     } catch (std::exception& e) {
21120       {
21121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21122       };
21123     } catch (Dali::DaliException e) {
21124       {
21125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21126       };
21127     } catch (...) {
21128       {
21129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21130       };
21131     }
21132   }
21133
21134 }
21135
21136
21137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21138   int jresult ;
21139   Dali::Property::Index result;
21140
21141   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21142   jresult = result;
21143   return jresult;
21144 }
21145
21146
21147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21148   void * jresult ;
21149   Dali::Handle result;
21150
21151   {
21152     try {
21153       result = Dali::WeightObject::New();
21154     } catch (std::out_of_range& e) {
21155       {
21156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21157       };
21158     } catch (std::exception& e) {
21159       {
21160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21161       };
21162     } catch (Dali::DaliException e) {
21163       {
21164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21165       };
21166     } catch (...) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21169       };
21170     }
21171   }
21172
21173   jresult = new Dali::Handle((const Dali::Handle &)result);
21174   return jresult;
21175 }
21176
21177
21178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21179   void * jresult ;
21180   Dali::TypeInfo *result = 0 ;
21181
21182   {
21183     try {
21184       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21185     } catch (std::out_of_range& e) {
21186       {
21187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (std::exception& e) {
21190       {
21191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21192       };
21193     } catch (Dali::DaliException e) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21196       };
21197     } catch (...) {
21198       {
21199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21200       };
21201     }
21202   }
21203
21204   jresult = (void *)result;
21205   return jresult;
21206 }
21207
21208
21209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21210   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21211
21212   arg1 = (Dali::TypeInfo *)jarg1;
21213   {
21214     try {
21215       delete arg1;
21216     } catch (std::out_of_range& e) {
21217       {
21218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21219       };
21220     } catch (std::exception& e) {
21221       {
21222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21223       };
21224     } catch (Dali::DaliException e) {
21225       {
21226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21227       };
21228     } catch (...) {
21229       {
21230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21231       };
21232     }
21233   }
21234
21235 }
21236
21237
21238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21239   void * jresult ;
21240   Dali::TypeInfo *arg1 = 0 ;
21241   Dali::TypeInfo *result = 0 ;
21242
21243   arg1 = (Dali::TypeInfo *)jarg1;
21244   if (!arg1) {
21245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21246     return 0;
21247   }
21248   {
21249     try {
21250       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21251     } catch (std::out_of_range& e) {
21252       {
21253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (std::exception& e) {
21256       {
21257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (Dali::DaliException e) {
21260       {
21261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21262       };
21263     } catch (...) {
21264       {
21265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21266       };
21267     }
21268   }
21269
21270   jresult = (void *)result;
21271   return jresult;
21272 }
21273
21274
21275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21276   void * jresult ;
21277   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21278   Dali::TypeInfo *arg2 = 0 ;
21279   Dali::TypeInfo *result = 0 ;
21280
21281   arg1 = (Dali::TypeInfo *)jarg1;
21282   arg2 = (Dali::TypeInfo *)jarg2;
21283   if (!arg2) {
21284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21285     return 0;
21286   }
21287   {
21288     try {
21289       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21290     } catch (std::out_of_range& e) {
21291       {
21292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21293       };
21294     } catch (std::exception& e) {
21295       {
21296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21297       };
21298     } catch (Dali::DaliException e) {
21299       {
21300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21301       };
21302     } catch (...) {
21303       {
21304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21305       };
21306     }
21307   }
21308
21309   jresult = (void *)result;
21310   return jresult;
21311 }
21312
21313
21314 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21315   char * jresult ;
21316   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21317   std::string *result = 0 ;
21318
21319   arg1 = (Dali::TypeInfo *)jarg1;
21320   {
21321     try {
21322       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21323     } catch (std::out_of_range& e) {
21324       {
21325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21326       };
21327     } catch (std::exception& e) {
21328       {
21329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21330       };
21331     } catch (Dali::DaliException e) {
21332       {
21333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21334       };
21335     } catch (...) {
21336       {
21337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21338       };
21339     }
21340   }
21341
21342   jresult = SWIG_csharp_string_callback(result->c_str());
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21348   char * jresult ;
21349   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21350   std::string *result = 0 ;
21351
21352   arg1 = (Dali::TypeInfo *)jarg1;
21353   {
21354     try {
21355       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21356     } catch (std::out_of_range& e) {
21357       {
21358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (std::exception& e) {
21361       {
21362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21363       };
21364     } catch (Dali::DaliException e) {
21365       {
21366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21367       };
21368     } catch (...) {
21369       {
21370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21371       };
21372     }
21373   }
21374
21375   jresult = SWIG_csharp_string_callback(result->c_str());
21376   return jresult;
21377 }
21378
21379
21380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21381   void * jresult ;
21382   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21383   Dali::BaseHandle result;
21384
21385   arg1 = (Dali::TypeInfo *)jarg1;
21386   {
21387     try {
21388       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21389     } catch (std::out_of_range& e) {
21390       {
21391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21392       };
21393     } catch (std::exception& e) {
21394       {
21395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21396       };
21397     } catch (Dali::DaliException e) {
21398       {
21399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21400       };
21401     } catch (...) {
21402       {
21403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21404       };
21405     }
21406   }
21407
21408   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21409   return jresult;
21410 }
21411
21412
21413 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21414   unsigned long jresult ;
21415   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21416   size_t result;
21417
21418   arg1 = (Dali::TypeInfo *)jarg1;
21419   {
21420     try {
21421       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21422     } catch (std::out_of_range& e) {
21423       {
21424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21425       };
21426     } catch (std::exception& e) {
21427       {
21428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21429       };
21430     } catch (Dali::DaliException e) {
21431       {
21432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21433       };
21434     } catch (...) {
21435       {
21436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21437       };
21438     }
21439   }
21440
21441   jresult = (unsigned long)result;
21442   return jresult;
21443 }
21444
21445
21446 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21447   char * jresult ;
21448   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21449   size_t arg2 ;
21450   std::string result;
21451
21452   arg1 = (Dali::TypeInfo *)jarg1;
21453   arg2 = (size_t)jarg2;
21454   {
21455     try {
21456       result = (arg1)->GetActionName(arg2);
21457     } catch (std::out_of_range& e) {
21458       {
21459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21460       };
21461     } catch (std::exception& e) {
21462       {
21463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21464       };
21465     } catch (Dali::DaliException e) {
21466       {
21467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21468       };
21469     } catch (...) {
21470       {
21471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21472       };
21473     }
21474   }
21475
21476   jresult = SWIG_csharp_string_callback((&result)->c_str());
21477   return jresult;
21478 }
21479
21480
21481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21482   unsigned long jresult ;
21483   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21484   size_t result;
21485
21486   arg1 = (Dali::TypeInfo *)jarg1;
21487   {
21488     try {
21489       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21490     } catch (std::out_of_range& e) {
21491       {
21492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21493       };
21494     } catch (std::exception& e) {
21495       {
21496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21497       };
21498     } catch (Dali::DaliException e) {
21499       {
21500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21501       };
21502     } catch (...) {
21503       {
21504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21505       };
21506     }
21507   }
21508
21509   jresult = (unsigned long)result;
21510   return jresult;
21511 }
21512
21513
21514 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21515   char * jresult ;
21516   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21517   size_t arg2 ;
21518   std::string result;
21519
21520   arg1 = (Dali::TypeInfo *)jarg1;
21521   arg2 = (size_t)jarg2;
21522   {
21523     try {
21524       result = (arg1)->GetSignalName(arg2);
21525     } catch (std::out_of_range& e) {
21526       {
21527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21528       };
21529     } catch (std::exception& e) {
21530       {
21531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21532       };
21533     } catch (Dali::DaliException e) {
21534       {
21535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21536       };
21537     } catch (...) {
21538       {
21539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21540       };
21541     }
21542   }
21543
21544   jresult = SWIG_csharp_string_callback((&result)->c_str());
21545   return jresult;
21546 }
21547
21548
21549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21550   unsigned long jresult ;
21551   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21552   size_t result;
21553
21554   arg1 = (Dali::TypeInfo *)jarg1;
21555   {
21556     try {
21557       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21558     } catch (std::out_of_range& e) {
21559       {
21560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21561       };
21562     } catch (std::exception& e) {
21563       {
21564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21565       };
21566     } catch (Dali::DaliException e) {
21567       {
21568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21569       };
21570     } catch (...) {
21571       {
21572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21573       };
21574     }
21575   }
21576
21577   jresult = (unsigned long)result;
21578   return jresult;
21579 }
21580
21581
21582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21583   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21584   Dali::Property::IndexContainer *arg2 = 0 ;
21585
21586   arg1 = (Dali::TypeInfo *)jarg1;
21587   arg2 = (Dali::Property::IndexContainer *)jarg2;
21588   if (!arg2) {
21589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21590     return ;
21591   }
21592   {
21593     try {
21594       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21595     } catch (std::out_of_range& e) {
21596       {
21597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21598       };
21599     } catch (std::exception& e) {
21600       {
21601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21602       };
21603     } catch (Dali::DaliException e) {
21604       {
21605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21606       };
21607     } catch (...) {
21608       {
21609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21610       };
21611     }
21612   }
21613
21614 }
21615
21616
21617 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21618   char * jresult ;
21619   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21620   Dali::Property::Index arg2 ;
21621   std::string *result = 0 ;
21622
21623   arg1 = (Dali::TypeInfo *)jarg1;
21624   arg2 = (Dali::Property::Index)jarg2;
21625   {
21626     try {
21627       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21628     } catch (std::out_of_range& e) {
21629       {
21630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21631       };
21632     } catch (std::exception& e) {
21633       {
21634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21635       };
21636     } catch (Dali::DaliException e) {
21637       {
21638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21639       };
21640     } catch (...) {
21641       {
21642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21643       };
21644     }
21645   }
21646
21647   jresult = SWIG_csharp_string_callback(result->c_str());
21648   return jresult;
21649 }
21650
21651
21652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21653   void * jresult ;
21654   Dali::TypeRegistry result;
21655
21656   {
21657     try {
21658       result = Dali::TypeRegistry::Get();
21659     } catch (std::out_of_range& e) {
21660       {
21661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21662       };
21663     } catch (std::exception& e) {
21664       {
21665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21666       };
21667     } catch (Dali::DaliException e) {
21668       {
21669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21670       };
21671     } catch (...) {
21672       {
21673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21674       };
21675     }
21676   }
21677
21678   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21679   return jresult;
21680 }
21681
21682
21683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21684   void * jresult ;
21685   Dali::TypeRegistry *result = 0 ;
21686
21687   {
21688     try {
21689       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21690     } catch (std::out_of_range& e) {
21691       {
21692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21693       };
21694     } catch (std::exception& e) {
21695       {
21696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21697       };
21698     } catch (Dali::DaliException e) {
21699       {
21700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21701       };
21702     } catch (...) {
21703       {
21704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21705       };
21706     }
21707   }
21708
21709   jresult = (void *)result;
21710   return jresult;
21711 }
21712
21713
21714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21715   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21716
21717   arg1 = (Dali::TypeRegistry *)jarg1;
21718   {
21719     try {
21720       delete arg1;
21721     } catch (std::out_of_range& e) {
21722       {
21723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21724       };
21725     } catch (std::exception& e) {
21726       {
21727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21728       };
21729     } catch (Dali::DaliException e) {
21730       {
21731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21732       };
21733     } catch (...) {
21734       {
21735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21736       };
21737     }
21738   }
21739
21740 }
21741
21742
21743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21744   void * jresult ;
21745   Dali::TypeRegistry *arg1 = 0 ;
21746   Dali::TypeRegistry *result = 0 ;
21747
21748   arg1 = (Dali::TypeRegistry *)jarg1;
21749   if (!arg1) {
21750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21751     return 0;
21752   }
21753   {
21754     try {
21755       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21756     } catch (std::out_of_range& e) {
21757       {
21758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21759       };
21760     } catch (std::exception& e) {
21761       {
21762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21763       };
21764     } catch (Dali::DaliException e) {
21765       {
21766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21767       };
21768     } catch (...) {
21769       {
21770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21771       };
21772     }
21773   }
21774
21775   jresult = (void *)result;
21776   return jresult;
21777 }
21778
21779
21780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21781   void * jresult ;
21782   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21783   Dali::TypeRegistry *arg2 = 0 ;
21784   Dali::TypeRegistry *result = 0 ;
21785
21786   arg1 = (Dali::TypeRegistry *)jarg1;
21787   arg2 = (Dali::TypeRegistry *)jarg2;
21788   if (!arg2) {
21789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21790     return 0;
21791   }
21792   {
21793     try {
21794       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21795     } catch (std::out_of_range& e) {
21796       {
21797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21798       };
21799     } catch (std::exception& e) {
21800       {
21801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (Dali::DaliException e) {
21804       {
21805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21806       };
21807     } catch (...) {
21808       {
21809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21810       };
21811     }
21812   }
21813
21814   jresult = (void *)result;
21815   return jresult;
21816 }
21817
21818
21819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21820   void * jresult ;
21821   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21822   std::string *arg2 = 0 ;
21823   Dali::TypeInfo result;
21824
21825   arg1 = (Dali::TypeRegistry *)jarg1;
21826   if (!jarg2) {
21827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21828     return 0;
21829   }
21830   std::string arg2_str(jarg2);
21831   arg2 = &arg2_str;
21832   {
21833     try {
21834       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21835     } catch (std::out_of_range& e) {
21836       {
21837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21838       };
21839     } catch (std::exception& e) {
21840       {
21841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21842       };
21843     } catch (Dali::DaliException e) {
21844       {
21845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21846       };
21847     } catch (...) {
21848       {
21849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21850       };
21851     }
21852   }
21853
21854   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21855
21856   //argout typemap for const std::string&
21857
21858   return jresult;
21859 }
21860
21861
21862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21863   void * jresult ;
21864   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21865   std::type_info *arg2 = 0 ;
21866   Dali::TypeInfo result;
21867
21868   arg1 = (Dali::TypeRegistry *)jarg1;
21869   arg2 = (std::type_info *)jarg2;
21870   if (!arg2) {
21871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21872     return 0;
21873   }
21874   {
21875     try {
21876       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21877     } catch (std::out_of_range& e) {
21878       {
21879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21880       };
21881     } catch (std::exception& e) {
21882       {
21883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21884       };
21885     } catch (Dali::DaliException e) {
21886       {
21887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21888       };
21889     } catch (...) {
21890       {
21891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21892       };
21893     }
21894   }
21895
21896   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21897   return jresult;
21898 }
21899
21900
21901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21902   unsigned long jresult ;
21903   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21904   size_t result;
21905
21906   arg1 = (Dali::TypeRegistry *)jarg1;
21907   {
21908     try {
21909       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21910     } catch (std::out_of_range& e) {
21911       {
21912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21913       };
21914     } catch (std::exception& e) {
21915       {
21916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21917       };
21918     } catch (Dali::DaliException e) {
21919       {
21920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21921       };
21922     } catch (...) {
21923       {
21924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21925       };
21926     }
21927   }
21928
21929   jresult = (unsigned long)result;
21930   return jresult;
21931 }
21932
21933
21934 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21935   char * jresult ;
21936   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21937   size_t arg2 ;
21938   std::string result;
21939
21940   arg1 = (Dali::TypeRegistry *)jarg1;
21941   arg2 = (size_t)jarg2;
21942   {
21943     try {
21944       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21945     } catch (std::out_of_range& e) {
21946       {
21947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21948       };
21949     } catch (std::exception& e) {
21950       {
21951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (Dali::DaliException e) {
21954       {
21955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21956       };
21957     } catch (...) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21960       };
21961     }
21962   }
21963
21964   jresult = SWIG_csharp_string_callback((&result)->c_str());
21965   return jresult;
21966 }
21967
21968
21969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21970   void * jresult ;
21971   std::type_info *arg1 = 0 ;
21972   std::type_info *arg2 = 0 ;
21973   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21974   Dali::TypeRegistration *result = 0 ;
21975
21976   arg1 = (std::type_info *)jarg1;
21977   if (!arg1) {
21978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21979     return 0;
21980   }
21981   arg2 = (std::type_info *)jarg2;
21982   if (!arg2) {
21983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21984     return 0;
21985   }
21986   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21987   {
21988     try {
21989       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21990     } catch (std::out_of_range& e) {
21991       {
21992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21993       };
21994     } catch (std::exception& e) {
21995       {
21996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21997       };
21998     } catch (Dali::DaliException e) {
21999       {
22000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22001       };
22002     } catch (...) {
22003       {
22004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22005       };
22006     }
22007   }
22008
22009   jresult = (void *)result;
22010   return jresult;
22011 }
22012
22013
22014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22015   void * jresult ;
22016   std::type_info *arg1 = 0 ;
22017   std::type_info *arg2 = 0 ;
22018   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22019   bool arg4 ;
22020   Dali::TypeRegistration *result = 0 ;
22021
22022   arg1 = (std::type_info *)jarg1;
22023   if (!arg1) {
22024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22025     return 0;
22026   }
22027   arg2 = (std::type_info *)jarg2;
22028   if (!arg2) {
22029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22030     return 0;
22031   }
22032   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22033   arg4 = jarg4 ? true : false;
22034   {
22035     try {
22036       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22037     } catch (std::out_of_range& e) {
22038       {
22039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22040       };
22041     } catch (std::exception& e) {
22042       {
22043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22044       };
22045     } catch (Dali::DaliException e) {
22046       {
22047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22048       };
22049     } catch (...) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22052       };
22053     }
22054   }
22055
22056   jresult = (void *)result;
22057   return jresult;
22058 }
22059
22060
22061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22062   void * jresult ;
22063   std::string *arg1 = 0 ;
22064   std::type_info *arg2 = 0 ;
22065   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22066   Dali::TypeRegistration *result = 0 ;
22067
22068   if (!jarg1) {
22069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22070     return 0;
22071   }
22072   std::string arg1_str(jarg1);
22073   arg1 = &arg1_str;
22074   arg2 = (std::type_info *)jarg2;
22075   if (!arg2) {
22076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22077     return 0;
22078   }
22079   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22080   {
22081     try {
22082       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22083     } catch (std::out_of_range& e) {
22084       {
22085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22086       };
22087     } catch (std::exception& e) {
22088       {
22089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22090       };
22091     } catch (Dali::DaliException e) {
22092       {
22093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22094       };
22095     } catch (...) {
22096       {
22097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22098       };
22099     }
22100   }
22101
22102   jresult = (void *)result;
22103
22104   //argout typemap for const std::string&
22105
22106   return jresult;
22107 }
22108
22109
22110 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22111   char * jresult ;
22112   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22113   std::string result;
22114
22115   arg1 = (Dali::TypeRegistration *)jarg1;
22116   {
22117     try {
22118       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22119     } catch (std::out_of_range& e) {
22120       {
22121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (std::exception& e) {
22124       {
22125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22126       };
22127     } catch (Dali::DaliException e) {
22128       {
22129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22130       };
22131     } catch (...) {
22132       {
22133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22134       };
22135     }
22136   }
22137
22138   jresult = SWIG_csharp_string_callback((&result)->c_str());
22139   return jresult;
22140 }
22141
22142
22143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22144   std::string *arg1 = 0 ;
22145   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22146
22147   if (!jarg1) {
22148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22149     return ;
22150   }
22151   std::string arg1_str(jarg1);
22152   arg1 = &arg1_str;
22153   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22154   {
22155     try {
22156       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22157     } catch (std::out_of_range& e) {
22158       {
22159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22160       };
22161     } catch (std::exception& e) {
22162       {
22163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22164       };
22165     } catch (Dali::DaliException e) {
22166       {
22167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22168       };
22169     } catch (...) {
22170       {
22171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22172       };
22173     }
22174   }
22175
22176
22177   //argout typemap for const std::string&
22178
22179 }
22180
22181
22182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22183   std::string *arg1 = 0 ;
22184   std::string *arg2 = 0 ;
22185   int arg3 ;
22186   Dali::Property::Type arg4 ;
22187   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22188   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22189
22190   if (!jarg1) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22192     return ;
22193   }
22194   std::string arg1_str(jarg1);
22195   arg1 = &arg1_str;
22196   if (!jarg2) {
22197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22198     return ;
22199   }
22200   std::string arg2_str(jarg2);
22201   arg2 = &arg2_str;
22202   arg3 = (int)jarg3;
22203   arg4 = (Dali::Property::Type)jarg4;
22204   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22205   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22206   {
22207     try {
22208       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22209     } catch (std::out_of_range& e) {
22210       {
22211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22212       };
22213     } catch (std::exception& e) {
22214       {
22215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22216       };
22217     } catch (Dali::DaliException e) {
22218       {
22219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22220       };
22221     } catch (...) {
22222       {
22223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22224       };
22225     }
22226   }
22227
22228
22229   //argout typemap for const std::string&
22230
22231
22232   //argout typemap for const std::string&
22233
22234 }
22235
22236
22237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22238   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22239
22240   arg1 = (Dali::TypeRegistration *)jarg1;
22241   {
22242     try {
22243       delete arg1;
22244     } catch (std::out_of_range& e) {
22245       {
22246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22247       };
22248     } catch (std::exception& e) {
22249       {
22250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22251       };
22252     } catch (Dali::DaliException e) {
22253       {
22254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22255       };
22256     } catch (...) {
22257       {
22258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22259       };
22260     }
22261   }
22262
22263 }
22264
22265
22266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22267   void * jresult ;
22268   Dali::TypeRegistration *arg1 = 0 ;
22269   std::string *arg2 = 0 ;
22270   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22271   Dali::SignalConnectorType *result = 0 ;
22272
22273   arg1 = (Dali::TypeRegistration *)jarg1;
22274   if (!arg1) {
22275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22276     return 0;
22277   }
22278   if (!jarg2) {
22279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22280     return 0;
22281   }
22282   std::string arg2_str(jarg2);
22283   arg2 = &arg2_str;
22284   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22285   {
22286     try {
22287       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22288     } catch (std::out_of_range& e) {
22289       {
22290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22291       };
22292     } catch (std::exception& e) {
22293       {
22294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22295       };
22296     } catch (Dali::DaliException e) {
22297       {
22298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22299       };
22300     } catch (...) {
22301       {
22302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22303       };
22304     }
22305   }
22306
22307   jresult = (void *)result;
22308
22309   //argout typemap for const std::string&
22310
22311   return jresult;
22312 }
22313
22314
22315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22316   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22317
22318   arg1 = (Dali::SignalConnectorType *)jarg1;
22319   {
22320     try {
22321       delete arg1;
22322     } catch (std::out_of_range& e) {
22323       {
22324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22325       };
22326     } catch (std::exception& e) {
22327       {
22328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22329       };
22330     } catch (Dali::DaliException e) {
22331       {
22332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22333       };
22334     } catch (...) {
22335       {
22336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22337       };
22338     }
22339   }
22340
22341 }
22342
22343
22344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22345   void * jresult ;
22346   Dali::TypeRegistration *arg1 = 0 ;
22347   std::string *arg2 = 0 ;
22348   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22349   Dali::TypeAction *result = 0 ;
22350
22351   arg1 = (Dali::TypeRegistration *)jarg1;
22352   if (!arg1) {
22353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22354     return 0;
22355   }
22356   if (!jarg2) {
22357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22358     return 0;
22359   }
22360   std::string arg2_str(jarg2);
22361   arg2 = &arg2_str;
22362   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22363   {
22364     try {
22365       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22366     } catch (std::out_of_range& e) {
22367       {
22368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22369       };
22370     } catch (std::exception& e) {
22371       {
22372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22373       };
22374     } catch (Dali::DaliException e) {
22375       {
22376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22377       };
22378     } catch (...) {
22379       {
22380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22381       };
22382     }
22383   }
22384
22385   jresult = (void *)result;
22386
22387   //argout typemap for const std::string&
22388
22389   return jresult;
22390 }
22391
22392
22393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22394   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22395
22396   arg1 = (Dali::TypeAction *)jarg1;
22397   {
22398     try {
22399       delete arg1;
22400     } catch (std::out_of_range& e) {
22401       {
22402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22403       };
22404     } catch (std::exception& e) {
22405       {
22406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22407       };
22408     } catch (Dali::DaliException e) {
22409       {
22410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22411       };
22412     } catch (...) {
22413       {
22414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22415       };
22416     }
22417   }
22418
22419 }
22420
22421
22422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22423   void * jresult ;
22424   Dali::TypeRegistration *arg1 = 0 ;
22425   std::string *arg2 = 0 ;
22426   Dali::Property::Index arg3 ;
22427   Dali::Property::Type arg4 ;
22428   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22429   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22430   Dali::PropertyRegistration *result = 0 ;
22431
22432   arg1 = (Dali::TypeRegistration *)jarg1;
22433   if (!arg1) {
22434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22435     return 0;
22436   }
22437   if (!jarg2) {
22438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22439     return 0;
22440   }
22441   std::string arg2_str(jarg2);
22442   arg2 = &arg2_str;
22443   arg3 = (Dali::Property::Index)jarg3;
22444   arg4 = (Dali::Property::Type)jarg4;
22445   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22446   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22447   {
22448     try {
22449       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22450     } catch (std::out_of_range& e) {
22451       {
22452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22453       };
22454     } catch (std::exception& e) {
22455       {
22456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22457       };
22458     } catch (Dali::DaliException e) {
22459       {
22460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22461       };
22462     } catch (...) {
22463       {
22464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22465       };
22466     }
22467   }
22468
22469   jresult = (void *)result;
22470
22471   //argout typemap for const std::string&
22472
22473   return jresult;
22474 }
22475
22476
22477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22478   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22479
22480   arg1 = (Dali::PropertyRegistration *)jarg1;
22481   {
22482     try {
22483       delete arg1;
22484     } catch (std::out_of_range& e) {
22485       {
22486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22487       };
22488     } catch (std::exception& e) {
22489       {
22490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22491       };
22492     } catch (Dali::DaliException e) {
22493       {
22494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22495       };
22496     } catch (...) {
22497       {
22498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22499       };
22500     }
22501   }
22502
22503 }
22504
22505
22506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22507   void * jresult ;
22508   Dali::TypeRegistration *arg1 = 0 ;
22509   std::string *arg2 = 0 ;
22510   Dali::Property::Index arg3 ;
22511   Dali::Property::Type arg4 ;
22512   Dali::AnimatablePropertyRegistration *result = 0 ;
22513
22514   arg1 = (Dali::TypeRegistration *)jarg1;
22515   if (!arg1) {
22516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22517     return 0;
22518   }
22519   if (!jarg2) {
22520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22521     return 0;
22522   }
22523   std::string arg2_str(jarg2);
22524   arg2 = &arg2_str;
22525   arg3 = (Dali::Property::Index)jarg3;
22526   arg4 = (Dali::Property::Type)jarg4;
22527   {
22528     try {
22529       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22530     } catch (std::out_of_range& e) {
22531       {
22532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22533       };
22534     } catch (std::exception& e) {
22535       {
22536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22537       };
22538     } catch (Dali::DaliException e) {
22539       {
22540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22541       };
22542     } catch (...) {
22543       {
22544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22545       };
22546     }
22547   }
22548
22549   jresult = (void *)result;
22550
22551   //argout typemap for const std::string&
22552
22553   return jresult;
22554 }
22555
22556
22557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22558   void * jresult ;
22559   Dali::TypeRegistration *arg1 = 0 ;
22560   std::string *arg2 = 0 ;
22561   Dali::Property::Index arg3 ;
22562   Dali::Property::Value *arg4 = 0 ;
22563   Dali::AnimatablePropertyRegistration *result = 0 ;
22564
22565   arg1 = (Dali::TypeRegistration *)jarg1;
22566   if (!arg1) {
22567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22568     return 0;
22569   }
22570   if (!jarg2) {
22571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22572     return 0;
22573   }
22574   std::string arg2_str(jarg2);
22575   arg2 = &arg2_str;
22576   arg3 = (Dali::Property::Index)jarg3;
22577   arg4 = (Dali::Property::Value *)jarg4;
22578   if (!arg4) {
22579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22580     return 0;
22581   }
22582   {
22583     try {
22584       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22585     } catch (std::out_of_range& e) {
22586       {
22587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (std::exception& e) {
22590       {
22591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22592       };
22593     } catch (Dali::DaliException e) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22596       };
22597     } catch (...) {
22598       {
22599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22600       };
22601     }
22602   }
22603
22604   jresult = (void *)result;
22605
22606   //argout typemap for const std::string&
22607
22608   return jresult;
22609 }
22610
22611
22612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22613   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22614
22615   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22616   {
22617     try {
22618       delete arg1;
22619     } catch (std::out_of_range& e) {
22620       {
22621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22622       };
22623     } catch (std::exception& e) {
22624       {
22625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22626       };
22627     } catch (Dali::DaliException e) {
22628       {
22629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22630       };
22631     } catch (...) {
22632       {
22633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22634       };
22635     }
22636   }
22637
22638 }
22639
22640
22641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22642   void * jresult ;
22643   Dali::TypeRegistration *arg1 = 0 ;
22644   std::string *arg2 = 0 ;
22645   Dali::Property::Index arg3 ;
22646   Dali::Property::Index arg4 ;
22647   unsigned int arg5 ;
22648   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22649
22650   arg1 = (Dali::TypeRegistration *)jarg1;
22651   if (!arg1) {
22652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22653     return 0;
22654   }
22655   if (!jarg2) {
22656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22657     return 0;
22658   }
22659   std::string arg2_str(jarg2);
22660   arg2 = &arg2_str;
22661   arg3 = (Dali::Property::Index)jarg3;
22662   arg4 = (Dali::Property::Index)jarg4;
22663   arg5 = (unsigned int)jarg5;
22664   {
22665     try {
22666       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22667     } catch (std::out_of_range& e) {
22668       {
22669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22670       };
22671     } catch (std::exception& e) {
22672       {
22673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22674       };
22675     } catch (Dali::DaliException e) {
22676       {
22677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22678       };
22679     } catch (...) {
22680       {
22681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22682       };
22683     }
22684   }
22685
22686   jresult = (void *)result;
22687
22688   //argout typemap for const std::string&
22689
22690   return jresult;
22691 }
22692
22693
22694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22695   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22696
22697   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22698   {
22699     try {
22700       delete arg1;
22701     } catch (std::out_of_range& e) {
22702       {
22703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22704       };
22705     } catch (std::exception& e) {
22706       {
22707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22708       };
22709     } catch (Dali::DaliException e) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22712       };
22713     } catch (...) {
22714       {
22715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22716       };
22717     }
22718   }
22719
22720 }
22721
22722
22723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22724   void * jresult ;
22725   Dali::TypeRegistration *arg1 = 0 ;
22726   std::string *arg2 = 0 ;
22727   Dali::Property::Index arg3 ;
22728   Dali::Property::Type arg4 ;
22729   Dali::ChildPropertyRegistration *result = 0 ;
22730
22731   arg1 = (Dali::TypeRegistration *)jarg1;
22732   if (!arg1) {
22733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22734     return 0;
22735   }
22736   if (!jarg2) {
22737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22738     return 0;
22739   }
22740   std::string arg2_str(jarg2);
22741   arg2 = &arg2_str;
22742   arg3 = (Dali::Property::Index)jarg3;
22743   arg4 = (Dali::Property::Type)jarg4;
22744   {
22745     try {
22746       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22747     } catch (std::out_of_range& e) {
22748       {
22749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22750       };
22751     } catch (std::exception& e) {
22752       {
22753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22754       };
22755     } catch (Dali::DaliException e) {
22756       {
22757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22758       };
22759     } catch (...) {
22760       {
22761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22762       };
22763     }
22764   }
22765
22766   jresult = (void *)result;
22767
22768   //argout typemap for const std::string&
22769
22770   return jresult;
22771 }
22772
22773
22774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22775   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22776
22777   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22778   {
22779     try {
22780       delete arg1;
22781     } catch (std::out_of_range& e) {
22782       {
22783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22784       };
22785     } catch (std::exception& e) {
22786       {
22787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22788       };
22789     } catch (Dali::DaliException e) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22792       };
22793     } catch (...) {
22794       {
22795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22796       };
22797     }
22798   }
22799
22800 }
22801
22802
22803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22804   unsigned int jresult ;
22805   std::string *arg1 = 0 ;
22806   std::type_info *arg2 = 0 ;
22807   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22808   bool result;
22809
22810   if (!jarg1) {
22811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22812     return 0;
22813   }
22814   std::string arg1_str(jarg1);
22815   arg1 = &arg1_str;
22816   arg2 = (std::type_info *)jarg2;
22817   if (!arg2) {
22818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22819     return 0;
22820   }
22821   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22822   {
22823     try {
22824       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22825     } catch (std::out_of_range& e) {
22826       {
22827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22828       };
22829     } catch (std::exception& e) {
22830       {
22831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22832       };
22833     } catch (Dali::DaliException e) {
22834       {
22835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22836       };
22837     } catch (...) {
22838       {
22839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22840       };
22841     }
22842   }
22843
22844   jresult = result;
22845
22846   //argout typemap for const std::string&
22847
22848   return jresult;
22849 }
22850
22851
22852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22853   unsigned int jresult ;
22854   std::string *arg1 = 0 ;
22855   std::string *arg2 = 0 ;
22856   Dali::Property::Index arg3 ;
22857   Dali::Property::Type arg4 ;
22858   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22859   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22860   bool result;
22861
22862   if (!jarg1) {
22863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22864     return 0;
22865   }
22866   std::string arg1_str(jarg1);
22867   arg1 = &arg1_str;
22868   if (!jarg2) {
22869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22870     return 0;
22871   }
22872   std::string arg2_str(jarg2);
22873   arg2 = &arg2_str;
22874   arg3 = (Dali::Property::Index)jarg3;
22875   arg4 = (Dali::Property::Type)jarg4;
22876   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22877   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22878   {
22879     try {
22880       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22881     } catch (std::out_of_range& e) {
22882       {
22883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22884       };
22885     } catch (std::exception& e) {
22886       {
22887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22888       };
22889     } catch (Dali::DaliException e) {
22890       {
22891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22892       };
22893     } catch (...) {
22894       {
22895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22896       };
22897     }
22898   }
22899
22900   jresult = result;
22901
22902   //argout typemap for const std::string&
22903
22904
22905   //argout typemap for const std::string&
22906
22907   return jresult;
22908 }
22909
22910
22911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22912   float jresult ;
22913   float result;
22914
22915   result = (float)(float)Dali::ParentOrigin::TOP;
22916   jresult = result;
22917   return jresult;
22918 }
22919
22920
22921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22922   float jresult ;
22923   float result;
22924
22925   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22926   jresult = result;
22927   return jresult;
22928 }
22929
22930
22931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22932   float jresult ;
22933   float result;
22934
22935   result = (float)(float)Dali::ParentOrigin::LEFT;
22936   jresult = result;
22937   return jresult;
22938 }
22939
22940
22941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22942   float jresult ;
22943   float result;
22944
22945   result = (float)(float)Dali::ParentOrigin::RIGHT;
22946   jresult = result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22952   float jresult ;
22953   float result;
22954
22955   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22956   jresult = result;
22957   return jresult;
22958 }
22959
22960
22961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22962   void * jresult ;
22963   Dali::Vector3 *result = 0 ;
22964
22965   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22966   jresult = (void *)result;
22967   return jresult;
22968 }
22969
22970
22971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22972   void * jresult ;
22973   Dali::Vector3 *result = 0 ;
22974
22975   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22976   jresult = (void *)result;
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22982   void * jresult ;
22983   Dali::Vector3 *result = 0 ;
22984
22985   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22986   jresult = (void *)result;
22987   return jresult;
22988 }
22989
22990
22991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22992   void * jresult ;
22993   Dali::Vector3 *result = 0 ;
22994
22995   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22996   jresult = (void *)result;
22997   return jresult;
22998 }
22999
23000
23001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23002   void * jresult ;
23003   Dali::Vector3 *result = 0 ;
23004
23005   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23012   void * jresult ;
23013   Dali::Vector3 *result = 0 ;
23014
23015   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23016   jresult = (void *)result;
23017   return jresult;
23018 }
23019
23020
23021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23022   void * jresult ;
23023   Dali::Vector3 *result = 0 ;
23024
23025   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23026   jresult = (void *)result;
23027   return jresult;
23028 }
23029
23030
23031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23032   void * jresult ;
23033   Dali::Vector3 *result = 0 ;
23034
23035   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23036   jresult = (void *)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23042   void * jresult ;
23043   Dali::Vector3 *result = 0 ;
23044
23045   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23052   float jresult ;
23053   float result;
23054
23055   result = (float)(float)Dali::AnchorPoint::TOP;
23056   jresult = result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23062   float jresult ;
23063   float result;
23064
23065   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23066   jresult = result;
23067   return jresult;
23068 }
23069
23070
23071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23072   float jresult ;
23073   float result;
23074
23075   result = (float)(float)Dali::AnchorPoint::LEFT;
23076   jresult = result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23082   float jresult ;
23083   float result;
23084
23085   result = (float)(float)Dali::AnchorPoint::RIGHT;
23086   jresult = result;
23087   return jresult;
23088 }
23089
23090
23091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23092   float jresult ;
23093   float result;
23094
23095   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23096   jresult = result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23102   void * jresult ;
23103   Dali::Vector3 *result = 0 ;
23104
23105   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23106   jresult = (void *)result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23112   void * jresult ;
23113   Dali::Vector3 *result = 0 ;
23114
23115   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23116   jresult = (void *)result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23122   void * jresult ;
23123   Dali::Vector3 *result = 0 ;
23124
23125   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23126   jresult = (void *)result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23132   void * jresult ;
23133   Dali::Vector3 *result = 0 ;
23134
23135   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23136   jresult = (void *)result;
23137   return jresult;
23138 }
23139
23140
23141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23142   void * jresult ;
23143   Dali::Vector3 *result = 0 ;
23144
23145   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23146   jresult = (void *)result;
23147   return jresult;
23148 }
23149
23150
23151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23152   void * jresult ;
23153   Dali::Vector3 *result = 0 ;
23154
23155   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23156   jresult = (void *)result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23162   void * jresult ;
23163   Dali::Vector3 *result = 0 ;
23164
23165   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23166   jresult = (void *)result;
23167   return jresult;
23168 }
23169
23170
23171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23172   void * jresult ;
23173   Dali::Vector3 *result = 0 ;
23174
23175   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23176   jresult = (void *)result;
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23182   void * jresult ;
23183   Dali::Vector3 *result = 0 ;
23184
23185   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23186   jresult = (void *)result;
23187   return jresult;
23188 }
23189
23190
23191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23192   void * jresult ;
23193   Dali::Vector4 *result = 0 ;
23194
23195   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23196   jresult = (void *)result;
23197   return jresult;
23198 }
23199
23200
23201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23202   void * jresult ;
23203   Dali::Vector4 *result = 0 ;
23204
23205   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23212   void * jresult ;
23213   Dali::Vector4 *result = 0 ;
23214
23215   result = (Dali::Vector4 *)&Dali::Color::RED;
23216   jresult = (void *)result;
23217   return jresult;
23218 }
23219
23220
23221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23222   void * jresult ;
23223   Dali::Vector4 *result = 0 ;
23224
23225   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23226   jresult = (void *)result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23232   void * jresult ;
23233   Dali::Vector4 *result = 0 ;
23234
23235   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23236   jresult = (void *)result;
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23242   void * jresult ;
23243   Dali::Vector4 *result = 0 ;
23244
23245   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23246   jresult = (void *)result;
23247   return jresult;
23248 }
23249
23250
23251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23252   void * jresult ;
23253   Dali::Vector4 *result = 0 ;
23254
23255   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23256   jresult = (void *)result;
23257   return jresult;
23258 }
23259
23260
23261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23262   void * jresult ;
23263   Dali::Vector4 *result = 0 ;
23264
23265   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23266   jresult = (void *)result;
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23272   void * jresult ;
23273   Dali::Vector4 *result = 0 ;
23274
23275   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23276   jresult = (void *)result;
23277   return jresult;
23278 }
23279
23280
23281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23282   float jresult ;
23283   float result;
23284
23285   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23286   jresult = result;
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23292   float jresult ;
23293   float result;
23294
23295   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23296   jresult = result;
23297   return jresult;
23298 }
23299
23300
23301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23302   float jresult ;
23303   float result;
23304
23305   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23306   jresult = result;
23307   return jresult;
23308 }
23309
23310
23311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23312   float jresult ;
23313   float result;
23314
23315   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23316   jresult = result;
23317   return jresult;
23318 }
23319
23320
23321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23322   float jresult ;
23323   float result;
23324
23325   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23326   jresult = result;
23327   return jresult;
23328 }
23329
23330
23331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23332   float jresult ;
23333   float result;
23334
23335   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23336   jresult = result;
23337   return jresult;
23338 }
23339
23340
23341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23342   float jresult ;
23343   float result;
23344
23345   result = (float)(float)Dali::Math::PI;
23346   jresult = result;
23347   return jresult;
23348 }
23349
23350
23351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23352   float jresult ;
23353   float result;
23354
23355   result = (float)(float)Dali::Math::PI_2;
23356   jresult = result;
23357   return jresult;
23358 }
23359
23360
23361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23362   float jresult ;
23363   float result;
23364
23365   result = (float)(float)Dali::Math::PI_4;
23366   jresult = result;
23367   return jresult;
23368 }
23369
23370
23371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23372   float jresult ;
23373   float result;
23374
23375   result = (float)(float)Dali::Math::PI_OVER_180;
23376   jresult = result;
23377   return jresult;
23378 }
23379
23380
23381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23382   float jresult ;
23383   float result;
23384
23385   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23386   jresult = result;
23387   return jresult;
23388 }
23389
23390
23391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23392   int jresult ;
23393   Dali::ResizePolicy::Type result;
23394
23395   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23396   jresult = (int)result;
23397   return jresult;
23398 }
23399
23400
23401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23402   unsigned long jresult ;
23403   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23404   Dali::VectorBase::SizeType result;
23405
23406   arg1 = (Dali::VectorBase *)jarg1;
23407   {
23408     try {
23409       result = ((Dali::VectorBase const *)arg1)->Count();
23410     } catch (std::out_of_range& e) {
23411       {
23412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23413       };
23414     } catch (std::exception& e) {
23415       {
23416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23417       };
23418     } catch (Dali::DaliException e) {
23419       {
23420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23421       };
23422     } catch (...) {
23423       {
23424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23425       };
23426     }
23427   }
23428
23429   jresult = (unsigned long)result;
23430   return jresult;
23431 }
23432
23433
23434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23435   unsigned long jresult ;
23436   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23437   Dali::VectorBase::SizeType result;
23438
23439   arg1 = (Dali::VectorBase *)jarg1;
23440   {
23441     try {
23442       result = ((Dali::VectorBase const *)arg1)->Size();
23443     } catch (std::out_of_range& e) {
23444       {
23445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23446       };
23447     } catch (std::exception& e) {
23448       {
23449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23450       };
23451     } catch (Dali::DaliException e) {
23452       {
23453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23454       };
23455     } catch (...) {
23456       {
23457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23458       };
23459     }
23460   }
23461
23462   jresult = (unsigned long)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23468   unsigned int jresult ;
23469   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23470   bool result;
23471
23472   arg1 = (Dali::VectorBase *)jarg1;
23473   {
23474     try {
23475       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23476     } catch (std::out_of_range& e) {
23477       {
23478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23479       };
23480     } catch (std::exception& e) {
23481       {
23482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23483       };
23484     } catch (Dali::DaliException e) {
23485       {
23486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23487       };
23488     } catch (...) {
23489       {
23490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23491       };
23492     }
23493   }
23494
23495   jresult = result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23501   unsigned long jresult ;
23502   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23503   Dali::VectorBase::SizeType result;
23504
23505   arg1 = (Dali::VectorBase *)jarg1;
23506   {
23507     try {
23508       result = ((Dali::VectorBase const *)arg1)->Capacity();
23509     } catch (std::out_of_range& e) {
23510       {
23511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23512       };
23513     } catch (std::exception& e) {
23514       {
23515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23516       };
23517     } catch (Dali::DaliException e) {
23518       {
23519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23520       };
23521     } catch (...) {
23522       {
23523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23524       };
23525     }
23526   }
23527
23528   jresult = (unsigned long)result;
23529   return jresult;
23530 }
23531
23532
23533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23534   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23535
23536   arg1 = (Dali::VectorBase *)jarg1;
23537   {
23538     try {
23539       (arg1)->Release();
23540     } catch (std::out_of_range& e) {
23541       {
23542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23543       };
23544     } catch (std::exception& e) {
23545       {
23546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23547       };
23548     } catch (Dali::DaliException e) {
23549       {
23550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23551       };
23552     } catch (...) {
23553       {
23554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23555       };
23556     }
23557   }
23558
23559 }
23560
23561
23562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23563   void * jresult ;
23564   Dali::Image *result = 0 ;
23565
23566   {
23567     try {
23568       result = (Dali::Image *)new Dali::Image();
23569     } catch (std::out_of_range& e) {
23570       {
23571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23572       };
23573     } catch (std::exception& e) {
23574       {
23575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23576       };
23577     } catch (Dali::DaliException e) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23580       };
23581     } catch (...) {
23582       {
23583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23584       };
23585     }
23586   }
23587
23588   jresult = (void *)result;
23589   return jresult;
23590 }
23591
23592
23593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23594   Dali::Image *arg1 = (Dali::Image *) 0 ;
23595
23596   arg1 = (Dali::Image *)jarg1;
23597   {
23598     try {
23599       delete arg1;
23600     } catch (std::out_of_range& e) {
23601       {
23602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23603       };
23604     } catch (std::exception& e) {
23605       {
23606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23607       };
23608     } catch (Dali::DaliException e) {
23609       {
23610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23611       };
23612     } catch (...) {
23613       {
23614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23615       };
23616     }
23617   }
23618
23619 }
23620
23621
23622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23623   void * jresult ;
23624   Dali::Image *arg1 = 0 ;
23625   Dali::Image *result = 0 ;
23626
23627   arg1 = (Dali::Image *)jarg1;
23628   if (!arg1) {
23629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23630     return 0;
23631   }
23632   {
23633     try {
23634       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23635     } catch (std::out_of_range& e) {
23636       {
23637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23638       };
23639     } catch (std::exception& e) {
23640       {
23641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23642       };
23643     } catch (Dali::DaliException e) {
23644       {
23645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23646       };
23647     } catch (...) {
23648       {
23649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23650       };
23651     }
23652   }
23653
23654   jresult = (void *)result;
23655   return jresult;
23656 }
23657
23658
23659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23660   void * jresult ;
23661   Dali::Image *arg1 = (Dali::Image *) 0 ;
23662   Dali::Image *arg2 = 0 ;
23663   Dali::Image *result = 0 ;
23664
23665   arg1 = (Dali::Image *)jarg1;
23666   arg2 = (Dali::Image *)jarg2;
23667   if (!arg2) {
23668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23669     return 0;
23670   }
23671   {
23672     try {
23673       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23674     } catch (std::out_of_range& e) {
23675       {
23676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23677       };
23678     } catch (std::exception& e) {
23679       {
23680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23681       };
23682     } catch (Dali::DaliException e) {
23683       {
23684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23685       };
23686     } catch (...) {
23687       {
23688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23689       };
23690     }
23691   }
23692
23693   jresult = (void *)result;
23694   return jresult;
23695 }
23696
23697
23698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23699   void * jresult ;
23700   Dali::BaseHandle arg1 ;
23701   Dali::BaseHandle *argp1 ;
23702   Dali::Image result;
23703
23704   argp1 = (Dali::BaseHandle *)jarg1;
23705   if (!argp1) {
23706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23707     return 0;
23708   }
23709   arg1 = *argp1;
23710   {
23711     try {
23712       result = Dali::Image::DownCast(arg1);
23713     } catch (std::out_of_range& e) {
23714       {
23715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23716       };
23717     } catch (std::exception& e) {
23718       {
23719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23720       };
23721     } catch (Dali::DaliException e) {
23722       {
23723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23724       };
23725     } catch (...) {
23726       {
23727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23728       };
23729     }
23730   }
23731
23732   jresult = new Dali::Image((const Dali::Image &)result);
23733   return jresult;
23734 }
23735
23736
23737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23738   unsigned int jresult ;
23739   Dali::Image *arg1 = (Dali::Image *) 0 ;
23740   unsigned int result;
23741
23742   arg1 = (Dali::Image *)jarg1;
23743   {
23744     try {
23745       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23746     } catch (std::out_of_range& e) {
23747       {
23748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23749       };
23750     } catch (std::exception& e) {
23751       {
23752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23753       };
23754     } catch (Dali::DaliException e) {
23755       {
23756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23757       };
23758     } catch (...) {
23759       {
23760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23761       };
23762     }
23763   }
23764
23765   jresult = result;
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23771   unsigned int jresult ;
23772   Dali::Image *arg1 = (Dali::Image *) 0 ;
23773   unsigned int result;
23774
23775   arg1 = (Dali::Image *)jarg1;
23776   {
23777     try {
23778       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23779     } catch (std::out_of_range& e) {
23780       {
23781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23782       };
23783     } catch (std::exception& e) {
23784       {
23785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23786       };
23787     } catch (Dali::DaliException e) {
23788       {
23789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23790       };
23791     } catch (...) {
23792       {
23793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23794       };
23795     }
23796   }
23797
23798   jresult = result;
23799   return jresult;
23800 }
23801
23802
23803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23804   void * jresult ;
23805   Dali::Image *arg1 = (Dali::Image *) 0 ;
23806   Dali::Image::ImageSignalType *result = 0 ;
23807
23808   arg1 = (Dali::Image *)jarg1;
23809   {
23810     try {
23811       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23812     } catch (std::out_of_range& e) {
23813       {
23814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23815       };
23816     } catch (std::exception& e) {
23817       {
23818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23819       };
23820     } catch (Dali::DaliException e) {
23821       {
23822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23823       };
23824     } catch (...) {
23825       {
23826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23827       };
23828     }
23829   }
23830
23831   jresult = (void *)result;
23832   return jresult;
23833 }
23834
23835
23836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23837   int jresult ;
23838   Dali::Pixel::Format result;
23839
23840   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23841   jresult = (int)result;
23842   return jresult;
23843 }
23844
23845
23846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23847   int jresult ;
23848   Dali::Pixel::Format result;
23849
23850   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23851   jresult = (int)result;
23852   return jresult;
23853 }
23854
23855
23856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23857   unsigned int jresult ;
23858   Dali::Pixel::Format arg1 ;
23859   bool result;
23860
23861   arg1 = (Dali::Pixel::Format)jarg1;
23862   {
23863     try {
23864       result = (bool)Dali::Pixel::HasAlpha(arg1);
23865     } catch (std::out_of_range& e) {
23866       {
23867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23868       };
23869     } catch (std::exception& e) {
23870       {
23871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23872       };
23873     } catch (Dali::DaliException e) {
23874       {
23875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23876       };
23877     } catch (...) {
23878       {
23879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23880       };
23881     }
23882   }
23883
23884   jresult = result;
23885   return jresult;
23886 }
23887
23888
23889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23890   unsigned int jresult ;
23891   Dali::Pixel::Format arg1 ;
23892   unsigned int result;
23893
23894   arg1 = (Dali::Pixel::Format)jarg1;
23895   {
23896     try {
23897       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23898     } catch (std::out_of_range& e) {
23899       {
23900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23901       };
23902     } catch (std::exception& e) {
23903       {
23904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23905       };
23906     } catch (Dali::DaliException e) {
23907       {
23908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23909       };
23910     } catch (...) {
23911       {
23912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23913       };
23914     }
23915   }
23916
23917   jresult = result;
23918   return jresult;
23919 }
23920
23921
23922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23923   Dali::Pixel::Format arg1 ;
23924   int *arg2 = 0 ;
23925   int *arg3 = 0 ;
23926
23927   arg1 = (Dali::Pixel::Format)jarg1;
23928   arg2 = (int *)jarg2;
23929   if (!arg2) {
23930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23931     return ;
23932   }
23933   arg3 = (int *)jarg3;
23934   if (!arg3) {
23935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23936     return ;
23937   }
23938   {
23939     try {
23940       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23941     } catch (std::out_of_range& e) {
23942       {
23943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23944       };
23945     } catch (std::exception& e) {
23946       {
23947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23948       };
23949     } catch (Dali::DaliException e) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23952       };
23953     } catch (...) {
23954       {
23955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23956       };
23957     }
23958   }
23959
23960 }
23961
23962
23963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23964   void * jresult ;
23965   unsigned char *arg1 = (unsigned char *) 0 ;
23966   unsigned int arg2 ;
23967   unsigned int arg3 ;
23968   unsigned int arg4 ;
23969   Dali::Pixel::Format arg5 ;
23970   Dali::PixelData::ReleaseFunction arg6 ;
23971   Dali::PixelData result;
23972
23973   arg1 = jarg1;
23974   arg2 = (unsigned int)jarg2;
23975   arg3 = (unsigned int)jarg3;
23976   arg4 = (unsigned int)jarg4;
23977   arg5 = (Dali::Pixel::Format)jarg5;
23978   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23979   {
23980     try {
23981       auto pixelBuffer = new unsigned char[jarg2];
23982       memcpy( pixelBuffer, arg1, arg2);
23983       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23984     } catch (std::out_of_range& e) {
23985       {
23986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (std::exception& e) {
23989       {
23990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23991       };
23992     } catch (Dali::DaliException e) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23995       };
23996     } catch (...) {
23997       {
23998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23999       };
24000     }
24001   }
24002
24003   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24004
24005
24006   return jresult;
24007 }
24008
24009
24010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24011   void * jresult ;
24012   Dali::PixelData *result = 0 ;
24013
24014   {
24015     try {
24016       result = (Dali::PixelData *)new Dali::PixelData();
24017     } catch (std::out_of_range& e) {
24018       {
24019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (std::exception& e) {
24022       {
24023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24024       };
24025     } catch (Dali::DaliException e) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24028       };
24029     } catch (...) {
24030       {
24031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24032       };
24033     }
24034   }
24035
24036   jresult = (void *)result;
24037   return jresult;
24038 }
24039
24040
24041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24042   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24043
24044   arg1 = (Dali::PixelData *)jarg1;
24045   {
24046     try {
24047       delete arg1;
24048     } catch (std::out_of_range& e) {
24049       {
24050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24051       };
24052     } catch (std::exception& e) {
24053       {
24054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24055       };
24056     } catch (Dali::DaliException e) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24059       };
24060     } catch (...) {
24061       {
24062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24063       };
24064     }
24065   }
24066
24067 }
24068
24069
24070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24071   void * jresult ;
24072   Dali::PixelData *arg1 = 0 ;
24073   Dali::PixelData *result = 0 ;
24074
24075   arg1 = (Dali::PixelData *)jarg1;
24076   if (!arg1) {
24077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24078     return 0;
24079   }
24080   {
24081     try {
24082       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24083     } catch (std::out_of_range& e) {
24084       {
24085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (std::exception& e) {
24088       {
24089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24090       };
24091     } catch (Dali::DaliException e) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24094       };
24095     } catch (...) {
24096       {
24097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24098       };
24099     }
24100   }
24101
24102   jresult = (void *)result;
24103   return jresult;
24104 }
24105
24106
24107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24108   void * jresult ;
24109   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24110   Dali::PixelData *arg2 = 0 ;
24111   Dali::PixelData *result = 0 ;
24112
24113   arg1 = (Dali::PixelData *)jarg1;
24114   arg2 = (Dali::PixelData *)jarg2;
24115   if (!arg2) {
24116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24117     return 0;
24118   }
24119   {
24120     try {
24121       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24122     } catch (std::out_of_range& e) {
24123       {
24124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (std::exception& e) {
24127       {
24128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (Dali::DaliException e) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24133       };
24134     } catch (...) {
24135       {
24136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24137       };
24138     }
24139   }
24140
24141   jresult = (void *)result;
24142   return jresult;
24143 }
24144
24145
24146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24147   unsigned int jresult ;
24148   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24149   unsigned int result;
24150
24151   arg1 = (Dali::PixelData *)jarg1;
24152   {
24153     try {
24154       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24155     } catch (std::out_of_range& e) {
24156       {
24157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (std::exception& e) {
24160       {
24161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24162       };
24163     } catch (Dali::DaliException e) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24166       };
24167     } catch (...) {
24168       {
24169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24170       };
24171     }
24172   }
24173
24174   jresult = result;
24175   return jresult;
24176 }
24177
24178
24179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24180   unsigned int jresult ;
24181   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24182   unsigned int result;
24183
24184   arg1 = (Dali::PixelData *)jarg1;
24185   {
24186     try {
24187       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24188     } catch (std::out_of_range& e) {
24189       {
24190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24191       };
24192     } catch (std::exception& e) {
24193       {
24194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24195       };
24196     } catch (Dali::DaliException e) {
24197       {
24198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24199       };
24200     } catch (...) {
24201       {
24202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24203       };
24204     }
24205   }
24206
24207   jresult = result;
24208   return jresult;
24209 }
24210
24211
24212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24213   int jresult ;
24214   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24215   Dali::Pixel::Format result;
24216
24217   arg1 = (Dali::PixelData *)jarg1;
24218   {
24219     try {
24220       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24221     } catch (std::out_of_range& e) {
24222       {
24223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24224       };
24225     } catch (std::exception& e) {
24226       {
24227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24228       };
24229     } catch (Dali::DaliException e) {
24230       {
24231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24232       };
24233     } catch (...) {
24234       {
24235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24236       };
24237     }
24238   }
24239
24240   jresult = (int)result;
24241   return jresult;
24242 }
24243
24244
24245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24246   unsigned int jresult ;
24247   unsigned int result;
24248
24249   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24250   jresult = result;
24251   return jresult;
24252 }
24253
24254
24255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24256   unsigned int jresult ;
24257   unsigned int result;
24258
24259   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24260   jresult = result;
24261   return jresult;
24262 }
24263
24264
24265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24266   unsigned int jresult ;
24267   unsigned int result;
24268
24269   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24270   jresult = result;
24271   return jresult;
24272 }
24273
24274
24275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24276   unsigned int jresult ;
24277   unsigned int result;
24278
24279   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24280   jresult = result;
24281   return jresult;
24282 }
24283
24284
24285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24286   unsigned int jresult ;
24287   unsigned int result;
24288
24289   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24290   jresult = result;
24291   return jresult;
24292 }
24293
24294
24295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24296   unsigned int jresult ;
24297   unsigned int result;
24298
24299   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24300   jresult = result;
24301   return jresult;
24302 }
24303
24304
24305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24306   void * jresult ;
24307   Dali::TextureType::Type arg1 ;
24308   Dali::Pixel::Format arg2 ;
24309   unsigned int arg3 ;
24310   unsigned int arg4 ;
24311   Dali::Texture result;
24312
24313   arg1 = (Dali::TextureType::Type)jarg1;
24314   arg2 = (Dali::Pixel::Format)jarg2;
24315   arg3 = (unsigned int)jarg3;
24316   arg4 = (unsigned int)jarg4;
24317   {
24318     try {
24319       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24320     } catch (std::out_of_range& e) {
24321       {
24322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24323       };
24324     } catch (std::exception& e) {
24325       {
24326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24327       };
24328     } catch (Dali::DaliException e) {
24329       {
24330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24331       };
24332     } catch (...) {
24333       {
24334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24335       };
24336     }
24337   }
24338
24339   jresult = new Dali::Texture((const Dali::Texture &)result);
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24345   void * jresult ;
24346   NativeImageInterface *arg1 = 0 ;
24347   Dali::Texture result;
24348
24349   arg1 = (NativeImageInterface *)jarg1;
24350   if (!arg1) {
24351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24352     return 0;
24353   }
24354   {
24355     try {
24356       result = Dali::Texture::New(*arg1);
24357     } catch (std::out_of_range& e) {
24358       {
24359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (std::exception& e) {
24362       {
24363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24364       };
24365     } catch (Dali::DaliException e) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24368       };
24369     } catch (...) {
24370       {
24371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24372       };
24373     }
24374   }
24375
24376   jresult = new Dali::Texture((const Dali::Texture &)result);
24377   return jresult;
24378 }
24379
24380
24381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24382   void * jresult ;
24383   Dali::Texture *result = 0 ;
24384
24385   {
24386     try {
24387       result = (Dali::Texture *)new Dali::Texture();
24388     } catch (std::out_of_range& e) {
24389       {
24390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (std::exception& e) {
24393       {
24394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24395       };
24396     } catch (Dali::DaliException e) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24399       };
24400     } catch (...) {
24401       {
24402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24403       };
24404     }
24405   }
24406
24407   jresult = (void *)result;
24408   return jresult;
24409 }
24410
24411
24412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24413   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24414
24415   arg1 = (Dali::Texture *)jarg1;
24416   {
24417     try {
24418       delete arg1;
24419     } catch (std::out_of_range& e) {
24420       {
24421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24422       };
24423     } catch (std::exception& e) {
24424       {
24425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24426       };
24427     } catch (Dali::DaliException e) {
24428       {
24429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24430       };
24431     } catch (...) {
24432       {
24433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24434       };
24435     }
24436   }
24437
24438 }
24439
24440
24441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24442   void * jresult ;
24443   Dali::Texture *arg1 = 0 ;
24444   Dali::Texture *result = 0 ;
24445
24446   arg1 = (Dali::Texture *)jarg1;
24447   if (!arg1) {
24448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24449     return 0;
24450   }
24451   {
24452     try {
24453       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24454     } catch (std::out_of_range& e) {
24455       {
24456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24457       };
24458     } catch (std::exception& e) {
24459       {
24460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24461       };
24462     } catch (Dali::DaliException e) {
24463       {
24464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24465       };
24466     } catch (...) {
24467       {
24468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24469       };
24470     }
24471   }
24472
24473   jresult = (void *)result;
24474   return jresult;
24475 }
24476
24477
24478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24479   void * jresult ;
24480   Dali::BaseHandle arg1 ;
24481   Dali::BaseHandle *argp1 ;
24482   Dali::Texture result;
24483
24484   argp1 = (Dali::BaseHandle *)jarg1;
24485   if (!argp1) {
24486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24487     return 0;
24488   }
24489   arg1 = *argp1;
24490   {
24491     try {
24492       result = Dali::Texture::DownCast(arg1);
24493     } catch (std::out_of_range& e) {
24494       {
24495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24496       };
24497     } catch (std::exception& e) {
24498       {
24499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24500       };
24501     } catch (Dali::DaliException e) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24504       };
24505     } catch (...) {
24506       {
24507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24508       };
24509     }
24510   }
24511
24512   jresult = new Dali::Texture((const Dali::Texture &)result);
24513   return jresult;
24514 }
24515
24516
24517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24518   void * jresult ;
24519   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24520   Dali::Texture *arg2 = 0 ;
24521   Dali::Texture *result = 0 ;
24522
24523   arg1 = (Dali::Texture *)jarg1;
24524   arg2 = (Dali::Texture *)jarg2;
24525   if (!arg2) {
24526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24527     return 0;
24528   }
24529   {
24530     try {
24531       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24532     } catch (std::out_of_range& e) {
24533       {
24534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (std::exception& e) {
24537       {
24538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24539       };
24540     } catch (Dali::DaliException e) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24543       };
24544     } catch (...) {
24545       {
24546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24547       };
24548     }
24549   }
24550
24551   jresult = (void *)result;
24552   return jresult;
24553 }
24554
24555
24556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24557   unsigned int jresult ;
24558   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24559   Dali::PixelData arg2 ;
24560   Dali::PixelData *argp2 ;
24561   bool result;
24562
24563   arg1 = (Dali::Texture *)jarg1;
24564   argp2 = (Dali::PixelData *)jarg2;
24565   if (!argp2) {
24566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24567     return 0;
24568   }
24569   arg2 = *argp2;
24570   {
24571     try {
24572       result = (bool)(arg1)->Upload(arg2);
24573     } catch (std::out_of_range& e) {
24574       {
24575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24576       };
24577     } catch (std::exception& e) {
24578       {
24579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24580       };
24581     } catch (Dali::DaliException e) {
24582       {
24583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24584       };
24585     } catch (...) {
24586       {
24587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24588       };
24589     }
24590   }
24591
24592   jresult = result;
24593   return jresult;
24594 }
24595
24596
24597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24598   unsigned int jresult ;
24599   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24600   Dali::PixelData arg2 ;
24601   unsigned int arg3 ;
24602   unsigned int arg4 ;
24603   unsigned int arg5 ;
24604   unsigned int arg6 ;
24605   unsigned int arg7 ;
24606   unsigned int arg8 ;
24607   Dali::PixelData *argp2 ;
24608   bool result;
24609
24610   arg1 = (Dali::Texture *)jarg1;
24611   argp2 = (Dali::PixelData *)jarg2;
24612   if (!argp2) {
24613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24614     return 0;
24615   }
24616   arg2 = *argp2;
24617   arg3 = (unsigned int)jarg3;
24618   arg4 = (unsigned int)jarg4;
24619   arg5 = (unsigned int)jarg5;
24620   arg6 = (unsigned int)jarg6;
24621   arg7 = (unsigned int)jarg7;
24622   arg8 = (unsigned int)jarg8;
24623   {
24624     try {
24625       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24626     } catch (std::out_of_range& e) {
24627       {
24628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (std::exception& e) {
24631       {
24632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24633       };
24634     } catch (Dali::DaliException e) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24637       };
24638     } catch (...) {
24639       {
24640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24641       };
24642     }
24643   }
24644
24645   jresult = result;
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24651   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24652
24653   arg1 = (Dali::Texture *)jarg1;
24654   {
24655     try {
24656       (arg1)->GenerateMipmaps();
24657     } catch (std::out_of_range& e) {
24658       {
24659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24660       };
24661     } catch (std::exception& e) {
24662       {
24663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24664       };
24665     } catch (Dali::DaliException e) {
24666       {
24667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24668       };
24669     } catch (...) {
24670       {
24671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24672       };
24673     }
24674   }
24675
24676 }
24677
24678
24679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24680   unsigned int jresult ;
24681   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24682   unsigned int result;
24683
24684   arg1 = (Dali::Texture *)jarg1;
24685   {
24686     try {
24687       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24688     } catch (std::out_of_range& e) {
24689       {
24690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24691       };
24692     } catch (std::exception& e) {
24693       {
24694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24695       };
24696     } catch (Dali::DaliException e) {
24697       {
24698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24699       };
24700     } catch (...) {
24701       {
24702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24703       };
24704     }
24705   }
24706
24707   jresult = result;
24708   return jresult;
24709 }
24710
24711
24712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24713   unsigned int jresult ;
24714   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24715   unsigned int result;
24716
24717   arg1 = (Dali::Texture *)jarg1;
24718   {
24719     try {
24720       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24721     } catch (std::out_of_range& e) {
24722       {
24723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24724       };
24725     } catch (std::exception& e) {
24726       {
24727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24728       };
24729     } catch (Dali::DaliException e) {
24730       {
24731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24732       };
24733     } catch (...) {
24734       {
24735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24736       };
24737     }
24738   }
24739
24740   jresult = result;
24741   return jresult;
24742 }
24743
24744
24745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24746   void * jresult ;
24747   Dali::Sampler result;
24748
24749   {
24750     try {
24751       result = Dali::Sampler::New();
24752     } catch (std::out_of_range& e) {
24753       {
24754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24755       };
24756     } catch (std::exception& e) {
24757       {
24758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24759       };
24760     } catch (Dali::DaliException e) {
24761       {
24762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24763       };
24764     } catch (...) {
24765       {
24766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24767       };
24768     }
24769   }
24770
24771   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24772   return jresult;
24773 }
24774
24775
24776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24777   void * jresult ;
24778   Dali::Sampler *result = 0 ;
24779
24780   {
24781     try {
24782       result = (Dali::Sampler *)new Dali::Sampler();
24783     } catch (std::out_of_range& e) {
24784       {
24785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24786       };
24787     } catch (std::exception& e) {
24788       {
24789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24790       };
24791     } catch (Dali::DaliException e) {
24792       {
24793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24794       };
24795     } catch (...) {
24796       {
24797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24798       };
24799     }
24800   }
24801
24802   jresult = (void *)result;
24803   return jresult;
24804 }
24805
24806
24807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24808   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24809
24810   arg1 = (Dali::Sampler *)jarg1;
24811   {
24812     try {
24813       delete arg1;
24814     } catch (std::out_of_range& e) {
24815       {
24816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (std::exception& e) {
24819       {
24820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24821       };
24822     } catch (Dali::DaliException e) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24825       };
24826     } catch (...) {
24827       {
24828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24829       };
24830     }
24831   }
24832
24833 }
24834
24835
24836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24837   void * jresult ;
24838   Dali::Sampler *arg1 = 0 ;
24839   Dali::Sampler *result = 0 ;
24840
24841   arg1 = (Dali::Sampler *)jarg1;
24842   if (!arg1) {
24843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24844     return 0;
24845   }
24846   {
24847     try {
24848       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24849     } catch (std::out_of_range& e) {
24850       {
24851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24852       };
24853     } catch (std::exception& e) {
24854       {
24855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24856       };
24857     } catch (Dali::DaliException e) {
24858       {
24859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24860       };
24861     } catch (...) {
24862       {
24863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24864       };
24865     }
24866   }
24867
24868   jresult = (void *)result;
24869   return jresult;
24870 }
24871
24872
24873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24874   void * jresult ;
24875   Dali::BaseHandle arg1 ;
24876   Dali::BaseHandle *argp1 ;
24877   Dali::Sampler result;
24878
24879   argp1 = (Dali::BaseHandle *)jarg1;
24880   if (!argp1) {
24881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24882     return 0;
24883   }
24884   arg1 = *argp1;
24885   {
24886     try {
24887       result = Dali::Sampler::DownCast(arg1);
24888     } catch (std::out_of_range& e) {
24889       {
24890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24891       };
24892     } catch (std::exception& e) {
24893       {
24894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24895       };
24896     } catch (Dali::DaliException e) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24899       };
24900     } catch (...) {
24901       {
24902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24903       };
24904     }
24905   }
24906
24907   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24908   return jresult;
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24913   void * jresult ;
24914   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24915   Dali::Sampler *arg2 = 0 ;
24916   Dali::Sampler *result = 0 ;
24917
24918   arg1 = (Dali::Sampler *)jarg1;
24919   arg2 = (Dali::Sampler *)jarg2;
24920   if (!arg2) {
24921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24922     return 0;
24923   }
24924   {
24925     try {
24926       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24927     } catch (std::out_of_range& e) {
24928       {
24929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24930       };
24931     } catch (std::exception& e) {
24932       {
24933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24934       };
24935     } catch (Dali::DaliException e) {
24936       {
24937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24938       };
24939     } catch (...) {
24940       {
24941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24942       };
24943     }
24944   }
24945
24946   jresult = (void *)result;
24947   return jresult;
24948 }
24949
24950
24951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24952   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24953   Dali::FilterMode::Type arg2 ;
24954   Dali::FilterMode::Type arg3 ;
24955
24956   arg1 = (Dali::Sampler *)jarg1;
24957   arg2 = (Dali::FilterMode::Type)jarg2;
24958   arg3 = (Dali::FilterMode::Type)jarg3;
24959   {
24960     try {
24961       (arg1)->SetFilterMode(arg2,arg3);
24962     } catch (std::out_of_range& e) {
24963       {
24964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (std::exception& e) {
24967       {
24968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24969       };
24970     } catch (Dali::DaliException e) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24973       };
24974     } catch (...) {
24975       {
24976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24977       };
24978     }
24979   }
24980
24981 }
24982
24983
24984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24985   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24986   Dali::WrapMode::Type arg2 ;
24987   Dali::WrapMode::Type arg3 ;
24988
24989   arg1 = (Dali::Sampler *)jarg1;
24990   arg2 = (Dali::WrapMode::Type)jarg2;
24991   arg3 = (Dali::WrapMode::Type)jarg3;
24992   {
24993     try {
24994       (arg1)->SetWrapMode(arg2,arg3);
24995     } catch (std::out_of_range& e) {
24996       {
24997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (std::exception& e) {
25000       {
25001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25002       };
25003     } catch (Dali::DaliException e) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25006       };
25007     } catch (...) {
25008       {
25009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25010       };
25011     }
25012   }
25013
25014 }
25015
25016
25017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25018   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25019   Dali::WrapMode::Type arg2 ;
25020   Dali::WrapMode::Type arg3 ;
25021   Dali::WrapMode::Type arg4 ;
25022
25023   arg1 = (Dali::Sampler *)jarg1;
25024   arg2 = (Dali::WrapMode::Type)jarg2;
25025   arg3 = (Dali::WrapMode::Type)jarg3;
25026   arg4 = (Dali::WrapMode::Type)jarg4;
25027   {
25028     try {
25029       (arg1)->SetWrapMode(arg2,arg3,arg4);
25030     } catch (std::out_of_range& e) {
25031       {
25032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25033       };
25034     } catch (std::exception& e) {
25035       {
25036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25037       };
25038     } catch (Dali::DaliException e) {
25039       {
25040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25041       };
25042     } catch (...) {
25043       {
25044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25045       };
25046     }
25047   }
25048
25049 }
25050
25051
25052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25053   void * jresult ;
25054   Dali::TextureSet result;
25055
25056   {
25057     try {
25058       result = Dali::TextureSet::New();
25059     } catch (std::out_of_range& e) {
25060       {
25061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25062       };
25063     } catch (std::exception& e) {
25064       {
25065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25066       };
25067     } catch (Dali::DaliException e) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25070       };
25071     } catch (...) {
25072       {
25073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25074       };
25075     }
25076   }
25077
25078   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25079   return jresult;
25080 }
25081
25082
25083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25084   void * jresult ;
25085   Dali::TextureSet *result = 0 ;
25086
25087   {
25088     try {
25089       result = (Dali::TextureSet *)new Dali::TextureSet();
25090     } catch (std::out_of_range& e) {
25091       {
25092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (std::exception& e) {
25095       {
25096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25097       };
25098     } catch (Dali::DaliException e) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25101       };
25102     } catch (...) {
25103       {
25104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25105       };
25106     }
25107   }
25108
25109   jresult = (void *)result;
25110   return jresult;
25111 }
25112
25113
25114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25115   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25116
25117   arg1 = (Dali::TextureSet *)jarg1;
25118   {
25119     try {
25120       delete arg1;
25121     } catch (std::out_of_range& e) {
25122       {
25123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (std::exception& e) {
25126       {
25127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25128       };
25129     } catch (Dali::DaliException e) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25132       };
25133     } catch (...) {
25134       {
25135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25136       };
25137     }
25138   }
25139
25140 }
25141
25142
25143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25144   void * jresult ;
25145   Dali::TextureSet *arg1 = 0 ;
25146   Dali::TextureSet *result = 0 ;
25147
25148   arg1 = (Dali::TextureSet *)jarg1;
25149   if (!arg1) {
25150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25151     return 0;
25152   }
25153   {
25154     try {
25155       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25156     } catch (std::out_of_range& e) {
25157       {
25158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25159       };
25160     } catch (std::exception& e) {
25161       {
25162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25163       };
25164     } catch (Dali::DaliException e) {
25165       {
25166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25167       };
25168     } catch (...) {
25169       {
25170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25171       };
25172     }
25173   }
25174
25175   jresult = (void *)result;
25176   return jresult;
25177 }
25178
25179
25180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25181   void * jresult ;
25182   Dali::BaseHandle arg1 ;
25183   Dali::BaseHandle *argp1 ;
25184   Dali::TextureSet result;
25185
25186   argp1 = (Dali::BaseHandle *)jarg1;
25187   if (!argp1) {
25188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25189     return 0;
25190   }
25191   arg1 = *argp1;
25192   {
25193     try {
25194       result = Dali::TextureSet::DownCast(arg1);
25195     } catch (std::out_of_range& e) {
25196       {
25197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (std::exception& e) {
25200       {
25201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25202       };
25203     } catch (Dali::DaliException e) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25206       };
25207     } catch (...) {
25208       {
25209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25210       };
25211     }
25212   }
25213
25214   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25220   void * jresult ;
25221   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25222   Dali::TextureSet *arg2 = 0 ;
25223   Dali::TextureSet *result = 0 ;
25224
25225   arg1 = (Dali::TextureSet *)jarg1;
25226   arg2 = (Dali::TextureSet *)jarg2;
25227   if (!arg2) {
25228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25229     return 0;
25230   }
25231   {
25232     try {
25233       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25234     } catch (std::out_of_range& e) {
25235       {
25236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (std::exception& e) {
25239       {
25240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25241       };
25242     } catch (Dali::DaliException e) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25245       };
25246     } catch (...) {
25247       {
25248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25249       };
25250     }
25251   }
25252
25253   jresult = (void *)result;
25254   return jresult;
25255 }
25256
25257
25258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25259   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25260   size_t arg2 ;
25261   Dali::Texture arg3 ;
25262   Dali::Texture *argp3 ;
25263
25264   arg1 = (Dali::TextureSet *)jarg1;
25265   arg2 = (size_t)jarg2;
25266   argp3 = (Dali::Texture *)jarg3;
25267   if (!argp3) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25269     return ;
25270   }
25271   arg3 = *argp3;
25272   {
25273     try {
25274       (arg1)->SetTexture(arg2,arg3);
25275     } catch (std::out_of_range& e) {
25276       {
25277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (std::exception& e) {
25280       {
25281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25282       };
25283     } catch (Dali::DaliException e) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25286       };
25287     } catch (...) {
25288       {
25289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25290       };
25291     }
25292   }
25293
25294 }
25295
25296
25297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25298   void * jresult ;
25299   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25300   size_t arg2 ;
25301   Dali::Texture result;
25302
25303   arg1 = (Dali::TextureSet *)jarg1;
25304   arg2 = (size_t)jarg2;
25305   {
25306     try {
25307       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25308     } catch (std::out_of_range& e) {
25309       {
25310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (std::exception& e) {
25313       {
25314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25315       };
25316     } catch (Dali::DaliException e) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25319       };
25320     } catch (...) {
25321       {
25322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25323       };
25324     }
25325   }
25326
25327   jresult = new Dali::Texture((const Dali::Texture &)result);
25328   return jresult;
25329 }
25330
25331
25332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25333   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25334   size_t arg2 ;
25335   Dali::Sampler arg3 ;
25336   Dali::Sampler *argp3 ;
25337
25338   arg1 = (Dali::TextureSet *)jarg1;
25339   arg2 = (size_t)jarg2;
25340   argp3 = (Dali::Sampler *)jarg3;
25341   if (!argp3) {
25342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25343     return ;
25344   }
25345   arg3 = *argp3;
25346   {
25347     try {
25348       (arg1)->SetSampler(arg2,arg3);
25349     } catch (std::out_of_range& e) {
25350       {
25351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (std::exception& e) {
25354       {
25355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25356       };
25357     } catch (Dali::DaliException e) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25360       };
25361     } catch (...) {
25362       {
25363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25364       };
25365     }
25366   }
25367
25368 }
25369
25370
25371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25372   void * jresult ;
25373   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25374   size_t arg2 ;
25375   Dali::Sampler result;
25376
25377   arg1 = (Dali::TextureSet *)jarg1;
25378   arg2 = (size_t)jarg2;
25379   {
25380     try {
25381       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25382     } catch (std::out_of_range& e) {
25383       {
25384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25385       };
25386     } catch (std::exception& e) {
25387       {
25388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25389       };
25390     } catch (Dali::DaliException e) {
25391       {
25392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25393       };
25394     } catch (...) {
25395       {
25396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25397       };
25398     }
25399   }
25400
25401   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25402   return jresult;
25403 }
25404
25405
25406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25407   unsigned long jresult ;
25408   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25409   size_t result;
25410
25411   arg1 = (Dali::TextureSet *)jarg1;
25412   {
25413     try {
25414       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25415     } catch (std::out_of_range& e) {
25416       {
25417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (std::exception& e) {
25420       {
25421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25422       };
25423     } catch (Dali::DaliException e) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25426       };
25427     } catch (...) {
25428       {
25429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25430       };
25431     }
25432   }
25433
25434   jresult = (unsigned long)result;
25435   return jresult;
25436 }
25437
25438
25439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25440   void * jresult ;
25441   Dali::Property::Map *arg1 = 0 ;
25442   Dali::PropertyBuffer result;
25443
25444   arg1 = (Dali::Property::Map *)jarg1;
25445   if (!arg1) {
25446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25447     return 0;
25448   }
25449   {
25450     try {
25451       result = Dali::PropertyBuffer::New(*arg1);
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (Dali::DaliException e) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25463       };
25464     } catch (...) {
25465       {
25466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25467       };
25468     }
25469   }
25470
25471   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25472   return jresult;
25473 }
25474
25475
25476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25477   void * jresult ;
25478   Dali::PropertyBuffer *result = 0 ;
25479
25480   {
25481     try {
25482       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25483     } catch (std::out_of_range& e) {
25484       {
25485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25486       };
25487     } catch (std::exception& e) {
25488       {
25489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25490       };
25491     } catch (Dali::DaliException e) {
25492       {
25493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25494       };
25495     } catch (...) {
25496       {
25497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25498       };
25499     }
25500   }
25501
25502   jresult = (void *)result;
25503   return jresult;
25504 }
25505
25506
25507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25508   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25509
25510   arg1 = (Dali::PropertyBuffer *)jarg1;
25511   {
25512     try {
25513       delete arg1;
25514     } catch (std::out_of_range& e) {
25515       {
25516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25517       };
25518     } catch (std::exception& e) {
25519       {
25520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25521       };
25522     } catch (Dali::DaliException e) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25525       };
25526     } catch (...) {
25527       {
25528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25529       };
25530     }
25531   }
25532
25533 }
25534
25535
25536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25537   void * jresult ;
25538   Dali::PropertyBuffer *arg1 = 0 ;
25539   Dali::PropertyBuffer *result = 0 ;
25540
25541   arg1 = (Dali::PropertyBuffer *)jarg1;
25542   if (!arg1) {
25543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25544     return 0;
25545   }
25546   {
25547     try {
25548       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25549     } catch (std::out_of_range& e) {
25550       {
25551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (std::exception& e) {
25554       {
25555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (Dali::DaliException e) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25560       };
25561     } catch (...) {
25562       {
25563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25564       };
25565     }
25566   }
25567
25568   jresult = (void *)result;
25569   return jresult;
25570 }
25571
25572
25573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25574   void * jresult ;
25575   Dali::BaseHandle arg1 ;
25576   Dali::BaseHandle *argp1 ;
25577   Dali::PropertyBuffer result;
25578
25579   argp1 = (Dali::BaseHandle *)jarg1;
25580   if (!argp1) {
25581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25582     return 0;
25583   }
25584   arg1 = *argp1;
25585   {
25586     try {
25587       result = Dali::PropertyBuffer::DownCast(arg1);
25588     } catch (std::out_of_range& e) {
25589       {
25590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25591       };
25592     } catch (std::exception& e) {
25593       {
25594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25595       };
25596     } catch (Dali::DaliException e) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25599       };
25600     } catch (...) {
25601       {
25602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25603       };
25604     }
25605   }
25606
25607   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25608   return jresult;
25609 }
25610
25611
25612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25613   void * jresult ;
25614   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25615   Dali::PropertyBuffer *arg2 = 0 ;
25616   Dali::PropertyBuffer *result = 0 ;
25617
25618   arg1 = (Dali::PropertyBuffer *)jarg1;
25619   arg2 = (Dali::PropertyBuffer *)jarg2;
25620   if (!arg2) {
25621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25622     return 0;
25623   }
25624   {
25625     try {
25626       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25627     } catch (std::out_of_range& e) {
25628       {
25629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (std::exception& e) {
25632       {
25633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25634       };
25635     } catch (Dali::DaliException e) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25638       };
25639     } catch (...) {
25640       {
25641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25642       };
25643     }
25644   }
25645
25646   jresult = (void *)result;
25647   return jresult;
25648 }
25649
25650
25651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25652   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25653   void *arg2 = (void *) 0 ;
25654   std::size_t arg3 ;
25655
25656   arg1 = (Dali::PropertyBuffer *)jarg1;
25657   arg2 = jarg2;
25658   arg3 = (std::size_t)jarg3;
25659   {
25660     try {
25661       (arg1)->SetData((void const *)arg2,arg3);
25662     } catch (std::out_of_range& e) {
25663       {
25664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (std::exception& e) {
25667       {
25668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25669       };
25670     } catch (Dali::DaliException e) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25673       };
25674     } catch (...) {
25675       {
25676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25677       };
25678     }
25679   }
25680
25681 }
25682
25683
25684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25685   unsigned long jresult ;
25686   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25687   std::size_t result;
25688
25689   arg1 = (Dali::PropertyBuffer *)jarg1;
25690   {
25691     try {
25692       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25693     } catch (std::out_of_range& e) {
25694       {
25695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25696       };
25697     } catch (std::exception& e) {
25698       {
25699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25700       };
25701     } catch (Dali::DaliException e) {
25702       {
25703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25704       };
25705     } catch (...) {
25706       {
25707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25708       };
25709     }
25710   }
25711
25712   jresult = (unsigned long)result;
25713   return jresult;
25714 }
25715
25716
25717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25718   void * jresult ;
25719   Dali::Geometry result;
25720
25721   {
25722     try {
25723       result = Dali::Geometry::New();
25724     } catch (std::out_of_range& e) {
25725       {
25726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25727       };
25728     } catch (std::exception& e) {
25729       {
25730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25731       };
25732     } catch (Dali::DaliException e) {
25733       {
25734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25735       };
25736     } catch (...) {
25737       {
25738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25739       };
25740     }
25741   }
25742
25743   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25744   return jresult;
25745 }
25746
25747
25748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25749   void * jresult ;
25750   Dali::Geometry *result = 0 ;
25751
25752   {
25753     try {
25754       result = (Dali::Geometry *)new Dali::Geometry();
25755     } catch (std::out_of_range& e) {
25756       {
25757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (std::exception& e) {
25760       {
25761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25762       };
25763     } catch (Dali::DaliException e) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25766       };
25767     } catch (...) {
25768       {
25769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25770       };
25771     }
25772   }
25773
25774   jresult = (void *)result;
25775   return jresult;
25776 }
25777
25778
25779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25780   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25781
25782   arg1 = (Dali::Geometry *)jarg1;
25783   {
25784     try {
25785       delete arg1;
25786     } catch (std::out_of_range& e) {
25787       {
25788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (std::exception& e) {
25791       {
25792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25793       };
25794     } catch (Dali::DaliException e) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25797       };
25798     } catch (...) {
25799       {
25800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25801       };
25802     }
25803   }
25804
25805 }
25806
25807
25808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25809   void * jresult ;
25810   Dali::Geometry *arg1 = 0 ;
25811   Dali::Geometry *result = 0 ;
25812
25813   arg1 = (Dali::Geometry *)jarg1;
25814   if (!arg1) {
25815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25816     return 0;
25817   }
25818   {
25819     try {
25820       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25821     } catch (std::out_of_range& e) {
25822       {
25823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25824       };
25825     } catch (std::exception& e) {
25826       {
25827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25828       };
25829     } catch (Dali::DaliException e) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25832       };
25833     } catch (...) {
25834       {
25835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25836       };
25837     }
25838   }
25839
25840   jresult = (void *)result;
25841   return jresult;
25842 }
25843
25844
25845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25846   void * jresult ;
25847   Dali::BaseHandle arg1 ;
25848   Dali::BaseHandle *argp1 ;
25849   Dali::Geometry result;
25850
25851   argp1 = (Dali::BaseHandle *)jarg1;
25852   if (!argp1) {
25853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25854     return 0;
25855   }
25856   arg1 = *argp1;
25857   {
25858     try {
25859       result = Dali::Geometry::DownCast(arg1);
25860     } catch (std::out_of_range& e) {
25861       {
25862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (std::exception& e) {
25865       {
25866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25867       };
25868     } catch (Dali::DaliException e) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25871       };
25872     } catch (...) {
25873       {
25874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25875       };
25876     }
25877   }
25878
25879   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25880   return jresult;
25881 }
25882
25883
25884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25885   void * jresult ;
25886   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25887   Dali::Geometry *arg2 = 0 ;
25888   Dali::Geometry *result = 0 ;
25889
25890   arg1 = (Dali::Geometry *)jarg1;
25891   arg2 = (Dali::Geometry *)jarg2;
25892   if (!arg2) {
25893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25894     return 0;
25895   }
25896   {
25897     try {
25898       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25899     } catch (std::out_of_range& e) {
25900       {
25901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (std::exception& e) {
25904       {
25905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25906       };
25907     } catch (Dali::DaliException e) {
25908       {
25909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25910       };
25911     } catch (...) {
25912       {
25913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25914       };
25915     }
25916   }
25917
25918   jresult = (void *)result;
25919   return jresult;
25920 }
25921
25922
25923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25924   unsigned long jresult ;
25925   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25926   Dali::PropertyBuffer *arg2 = 0 ;
25927   std::size_t result;
25928
25929   arg1 = (Dali::Geometry *)jarg1;
25930   arg2 = (Dali::PropertyBuffer *)jarg2;
25931   if (!arg2) {
25932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25933     return 0;
25934   }
25935   {
25936     try {
25937       result = (arg1)->AddVertexBuffer(*arg2);
25938     } catch (std::out_of_range& e) {
25939       {
25940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25941       };
25942     } catch (std::exception& e) {
25943       {
25944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25945       };
25946     } catch (Dali::DaliException e) {
25947       {
25948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25949       };
25950     } catch (...) {
25951       {
25952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25953       };
25954     }
25955   }
25956
25957   jresult = (unsigned long)result;
25958   return jresult;
25959 }
25960
25961
25962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25963   unsigned long jresult ;
25964   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25965   std::size_t result;
25966
25967   arg1 = (Dali::Geometry *)jarg1;
25968   {
25969     try {
25970       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25971     } catch (std::out_of_range& e) {
25972       {
25973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (std::exception& e) {
25976       {
25977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25978       };
25979     } catch (Dali::DaliException e) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25982       };
25983     } catch (...) {
25984       {
25985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25986       };
25987     }
25988   }
25989
25990   jresult = (unsigned long)result;
25991   return jresult;
25992 }
25993
25994
25995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25996   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25997   std::size_t arg2 ;
25998
25999   arg1 = (Dali::Geometry *)jarg1;
26000   arg2 = (std::size_t)jarg2;
26001   {
26002     try {
26003       (arg1)->RemoveVertexBuffer(arg2);
26004     } catch (std::out_of_range& e) {
26005       {
26006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (std::exception& e) {
26009       {
26010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26011       };
26012     } catch (Dali::DaliException e) {
26013       {
26014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26015       };
26016     } catch (...) {
26017       {
26018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26019       };
26020     }
26021   }
26022
26023 }
26024
26025
26026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26027   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26028   unsigned short *arg2 = (unsigned short *) 0 ;
26029   size_t arg3 ;
26030
26031   arg1 = (Dali::Geometry *)jarg1;
26032   arg2 = jarg2;
26033   arg3 = (size_t)jarg3;
26034   {
26035     try {
26036       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26037     } catch (std::out_of_range& e) {
26038       {
26039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26040       };
26041     } catch (std::exception& e) {
26042       {
26043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26044       };
26045     } catch (Dali::DaliException e) {
26046       {
26047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26048       };
26049     } catch (...) {
26050       {
26051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26052       };
26053     }
26054   }
26055
26056
26057
26058 }
26059
26060
26061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26062   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26063   Dali::Geometry::Type arg2 ;
26064
26065   arg1 = (Dali::Geometry *)jarg1;
26066   arg2 = (Dali::Geometry::Type)jarg2;
26067   {
26068     try {
26069       (arg1)->SetType(arg2);
26070     } catch (std::out_of_range& e) {
26071       {
26072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26073       };
26074     } catch (std::exception& e) {
26075       {
26076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26077       };
26078     } catch (Dali::DaliException e) {
26079       {
26080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26081       };
26082     } catch (...) {
26083       {
26084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26085       };
26086     }
26087   }
26088
26089 }
26090
26091
26092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26093   int jresult ;
26094   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26095   Dali::Geometry::Type result;
26096
26097   arg1 = (Dali::Geometry *)jarg1;
26098   {
26099     try {
26100       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26101     } catch (std::out_of_range& e) {
26102       {
26103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26104       };
26105     } catch (std::exception& e) {
26106       {
26107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26108       };
26109     } catch (Dali::DaliException e) {
26110       {
26111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26112       };
26113     } catch (...) {
26114       {
26115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26116       };
26117     }
26118   }
26119
26120   jresult = (int)result;
26121   return jresult;
26122 }
26123
26124
26125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26126   void * jresult ;
26127   Dali::Shader::Hint *result = 0 ;
26128
26129   {
26130     try {
26131       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26132     } catch (std::out_of_range& e) {
26133       {
26134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26135       };
26136     } catch (std::exception& e) {
26137       {
26138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26139       };
26140     } catch (Dali::DaliException e) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26143       };
26144     } catch (...) {
26145       {
26146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26147       };
26148     }
26149   }
26150
26151   jresult = (void *)result;
26152   return jresult;
26153 }
26154
26155
26156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26157   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26158
26159   arg1 = (Dali::Shader::Hint *)jarg1;
26160   {
26161     try {
26162       delete arg1;
26163     } catch (std::out_of_range& e) {
26164       {
26165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26166       };
26167     } catch (std::exception& e) {
26168       {
26169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26170       };
26171     } catch (Dali::DaliException e) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26174       };
26175     } catch (...) {
26176       {
26177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26178       };
26179     }
26180   }
26181
26182 }
26183
26184
26185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26186   int jresult ;
26187   int result;
26188
26189   result = (int)Dali::Shader::Property::PROGRAM;
26190   jresult = (int)result;
26191   return jresult;
26192 }
26193
26194
26195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26196   void * jresult ;
26197   Dali::Shader::Property *result = 0 ;
26198
26199   {
26200     try {
26201       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26202     } catch (std::out_of_range& e) {
26203       {
26204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (std::exception& e) {
26207       {
26208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26209       };
26210     } catch (Dali::DaliException e) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26213       };
26214     } catch (...) {
26215       {
26216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26217       };
26218     }
26219   }
26220
26221   jresult = (void *)result;
26222   return jresult;
26223 }
26224
26225
26226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26227   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26228
26229   arg1 = (Dali::Shader::Property *)jarg1;
26230   {
26231     try {
26232       delete arg1;
26233     } catch (std::out_of_range& e) {
26234       {
26235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26236       };
26237     } catch (std::exception& e) {
26238       {
26239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26240       };
26241     } catch (Dali::DaliException e) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26244       };
26245     } catch (...) {
26246       {
26247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26248       };
26249     }
26250   }
26251
26252 }
26253
26254
26255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26256   void * jresult ;
26257   std::string *arg1 = 0 ;
26258   std::string *arg2 = 0 ;
26259   Dali::Shader::Hint::Value arg3 ;
26260   Dali::Shader result;
26261
26262   if (!jarg1) {
26263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26264     return 0;
26265   }
26266   std::string arg1_str(jarg1);
26267   arg1 = &arg1_str;
26268   if (!jarg2) {
26269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26270     return 0;
26271   }
26272   std::string arg2_str(jarg2);
26273   arg2 = &arg2_str;
26274   arg3 = (Dali::Shader::Hint::Value)jarg3;
26275   {
26276     try {
26277       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26278     } catch (std::out_of_range& e) {
26279       {
26280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (std::exception& e) {
26283       {
26284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26285       };
26286     } catch (Dali::DaliException e) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26289       };
26290     } catch (...) {
26291       {
26292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26293       };
26294     }
26295   }
26296
26297   jresult = new Dali::Shader((const Dali::Shader &)result);
26298
26299   //argout typemap for const std::string&
26300
26301
26302   //argout typemap for const std::string&
26303
26304   return jresult;
26305 }
26306
26307
26308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26309   void * jresult ;
26310   std::string *arg1 = 0 ;
26311   std::string *arg2 = 0 ;
26312   Dali::Shader result;
26313
26314   if (!jarg1) {
26315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26316     return 0;
26317   }
26318   std::string arg1_str(jarg1);
26319   arg1 = &arg1_str;
26320   if (!jarg2) {
26321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26322     return 0;
26323   }
26324   std::string arg2_str(jarg2);
26325   arg2 = &arg2_str;
26326   {
26327     try {
26328       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26329     } catch (std::out_of_range& e) {
26330       {
26331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26332       };
26333     } catch (std::exception& e) {
26334       {
26335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26336       };
26337     } catch (Dali::DaliException e) {
26338       {
26339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26340       };
26341     } catch (...) {
26342       {
26343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26344       };
26345     }
26346   }
26347
26348   jresult = new Dali::Shader((const Dali::Shader &)result);
26349
26350   //argout typemap for const std::string&
26351
26352
26353   //argout typemap for const std::string&
26354
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26360   void * jresult ;
26361   Dali::Shader *result = 0 ;
26362
26363   {
26364     try {
26365       result = (Dali::Shader *)new Dali::Shader();
26366     } catch (std::out_of_range& e) {
26367       {
26368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (std::exception& e) {
26371       {
26372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (Dali::DaliException e) {
26375       {
26376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384
26385   jresult = (void *)result;
26386   return jresult;
26387 }
26388
26389
26390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26391   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26392
26393   arg1 = (Dali::Shader *)jarg1;
26394   {
26395     try {
26396       delete arg1;
26397     } catch (std::out_of_range& e) {
26398       {
26399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26400       };
26401     } catch (std::exception& e) {
26402       {
26403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26404       };
26405     } catch (Dali::DaliException e) {
26406       {
26407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26408       };
26409     } catch (...) {
26410       {
26411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26412       };
26413     }
26414   }
26415
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26420   void * jresult ;
26421   Dali::Shader *arg1 = 0 ;
26422   Dali::Shader *result = 0 ;
26423
26424   arg1 = (Dali::Shader *)jarg1;
26425   if (!arg1) {
26426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26427     return 0;
26428   }
26429   {
26430     try {
26431       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26432     } catch (std::out_of_range& e) {
26433       {
26434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (std::exception& e) {
26437       {
26438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26439       };
26440     } catch (Dali::DaliException e) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26443       };
26444     } catch (...) {
26445       {
26446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26447       };
26448     }
26449   }
26450
26451   jresult = (void *)result;
26452   return jresult;
26453 }
26454
26455
26456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26457   void * jresult ;
26458   Dali::BaseHandle arg1 ;
26459   Dali::BaseHandle *argp1 ;
26460   Dali::Shader result;
26461
26462   argp1 = (Dali::BaseHandle *)jarg1;
26463   if (!argp1) {
26464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26465     return 0;
26466   }
26467   arg1 = *argp1;
26468   {
26469     try {
26470       result = Dali::Shader::DownCast(arg1);
26471     } catch (std::out_of_range& e) {
26472       {
26473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (std::exception& e) {
26476       {
26477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26478       };
26479     } catch (Dali::DaliException e) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26482       };
26483     } catch (...) {
26484       {
26485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26486       };
26487     }
26488   }
26489
26490   jresult = new Dali::Shader((const Dali::Shader &)result);
26491   return jresult;
26492 }
26493
26494
26495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26496   void * jresult ;
26497   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26498   Dali::Shader *arg2 = 0 ;
26499   Dali::Shader *result = 0 ;
26500
26501   arg1 = (Dali::Shader *)jarg1;
26502   arg2 = (Dali::Shader *)jarg2;
26503   if (!arg2) {
26504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26505     return 0;
26506   }
26507   {
26508     try {
26509       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26510     } catch (std::out_of_range& e) {
26511       {
26512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26513       };
26514     } catch (std::exception& e) {
26515       {
26516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26517       };
26518     } catch (Dali::DaliException e) {
26519       {
26520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26521       };
26522     } catch (...) {
26523       {
26524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26525       };
26526     }
26527   }
26528
26529   jresult = (void *)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26585   int jresult ;
26586   int result;
26587
26588   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26589   jresult = (int)result;
26590   return jresult;
26591 }
26592
26593
26594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26595   int jresult ;
26596   int result;
26597
26598   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26599   jresult = (int)result;
26600   return jresult;
26601 }
26602
26603
26604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26605   int jresult ;
26606   int result;
26607
26608   result = (int)Dali::Renderer::Property::BLEND_MODE;
26609   jresult = (int)result;
26610   return jresult;
26611 }
26612
26613
26614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26615   int jresult ;
26616   int result;
26617
26618   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26619   jresult = (int)result;
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26625   int jresult ;
26626   int result;
26627
26628   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26629   jresult = (int)result;
26630   return jresult;
26631 }
26632
26633
26634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26635   int jresult ;
26636   int result;
26637
26638   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26639   jresult = (int)result;
26640   return jresult;
26641 }
26642
26643
26644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26645   int jresult ;
26646   int result;
26647
26648   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26649   jresult = (int)result;
26650   return jresult;
26651 }
26652
26653
26654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26655   int jresult ;
26656   int result;
26657
26658   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26659   jresult = (int)result;
26660   return jresult;
26661 }
26662
26663
26664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26665   int jresult ;
26666   int result;
26667
26668   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26669   jresult = (int)result;
26670   return jresult;
26671 }
26672
26673
26674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26675   int jresult ;
26676   int result;
26677
26678   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26679   jresult = (int)result;
26680   return jresult;
26681 }
26682
26683
26684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26685   int jresult ;
26686   int result;
26687
26688   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26689   jresult = (int)result;
26690   return jresult;
26691 }
26692
26693
26694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26695   int jresult ;
26696   int result;
26697
26698   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26699   jresult = (int)result;
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26705   int jresult ;
26706   int result;
26707
26708   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26709   jresult = (int)result;
26710   return jresult;
26711 }
26712
26713
26714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26715   int jresult ;
26716   int result;
26717
26718   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26719   jresult = (int)result;
26720   return jresult;
26721 }
26722
26723
26724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26725   int jresult ;
26726   int result;
26727
26728   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26729   jresult = (int)result;
26730   return jresult;
26731 }
26732
26733
26734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26735   int jresult ;
26736   int result;
26737
26738   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26739   jresult = (int)result;
26740   return jresult;
26741 }
26742
26743
26744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26745   int jresult ;
26746   int result;
26747
26748   result = (int)Dali::Renderer::Property::RENDER_MODE;
26749   jresult = (int)result;
26750   return jresult;
26751 }
26752
26753
26754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26755   int jresult ;
26756   int result;
26757
26758   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26759   jresult = (int)result;
26760   return jresult;
26761 }
26762
26763
26764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26765   int jresult ;
26766   int result;
26767
26768   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26769   jresult = (int)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26775   int jresult ;
26776   int result;
26777
26778   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26779   jresult = (int)result;
26780   return jresult;
26781 }
26782
26783
26784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26785   int jresult ;
26786   int result;
26787
26788   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26789   jresult = (int)result;
26790   return jresult;
26791 }
26792
26793
26794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26795   int jresult ;
26796   int result;
26797
26798   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26799   jresult = (int)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26805   int jresult ;
26806   int result;
26807
26808   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26809   jresult = (int)result;
26810   return jresult;
26811 }
26812
26813
26814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26815   int jresult ;
26816   int result;
26817
26818   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26819   jresult = (int)result;
26820   return jresult;
26821 }
26822
26823
26824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26825   void * jresult ;
26826   Dali::Renderer::Property *result = 0 ;
26827
26828   {
26829     try {
26830       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26831     } catch (std::out_of_range& e) {
26832       {
26833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26834       };
26835     } catch (std::exception& e) {
26836       {
26837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26838       };
26839     } catch (Dali::DaliException e) {
26840       {
26841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26842       };
26843     } catch (...) {
26844       {
26845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26846       };
26847     }
26848   }
26849
26850   jresult = (void *)result;
26851   return jresult;
26852 }
26853
26854
26855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26856   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26857
26858   arg1 = (Dali::Renderer::Property *)jarg1;
26859   {
26860     try {
26861       delete arg1;
26862     } catch (std::out_of_range& e) {
26863       {
26864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26865       };
26866     } catch (std::exception& e) {
26867       {
26868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26869       };
26870     } catch (Dali::DaliException e) {
26871       {
26872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26873       };
26874     } catch (...) {
26875       {
26876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26877       };
26878     }
26879   }
26880
26881 }
26882
26883
26884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26885   void * jresult ;
26886   Dali::Geometry *arg1 = 0 ;
26887   Dali::Shader *arg2 = 0 ;
26888   Dali::Renderer result;
26889
26890   arg1 = (Dali::Geometry *)jarg1;
26891   if (!arg1) {
26892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26893     return 0;
26894   }
26895   arg2 = (Dali::Shader *)jarg2;
26896   if (!arg2) {
26897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26898     return 0;
26899   }
26900   {
26901     try {
26902       result = Dali::Renderer::New(*arg1,*arg2);
26903     } catch (std::out_of_range& e) {
26904       {
26905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26906       };
26907     } catch (std::exception& e) {
26908       {
26909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26910       };
26911     } catch (Dali::DaliException e) {
26912       {
26913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26914       };
26915     } catch (...) {
26916       {
26917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26918       };
26919     }
26920   }
26921
26922   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26923   return jresult;
26924 }
26925
26926
26927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26928   void * jresult ;
26929   Dali::Renderer *result = 0 ;
26930
26931   {
26932     try {
26933       result = (Dali::Renderer *)new Dali::Renderer();
26934     } catch (std::out_of_range& e) {
26935       {
26936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26937       };
26938     } catch (std::exception& e) {
26939       {
26940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26941       };
26942     } catch (Dali::DaliException e) {
26943       {
26944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26945       };
26946     } catch (...) {
26947       {
26948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26949       };
26950     }
26951   }
26952
26953   jresult = (void *)result;
26954   return jresult;
26955 }
26956
26957
26958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26959   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26960
26961   arg1 = (Dali::Renderer *)jarg1;
26962   {
26963     try {
26964       delete arg1;
26965     } catch (std::out_of_range& e) {
26966       {
26967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (std::exception& e) {
26970       {
26971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26972       };
26973     } catch (Dali::DaliException e) {
26974       {
26975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26976       };
26977     } catch (...) {
26978       {
26979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26980       };
26981     }
26982   }
26983
26984 }
26985
26986
26987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26988   void * jresult ;
26989   Dali::Renderer *arg1 = 0 ;
26990   Dali::Renderer *result = 0 ;
26991
26992   arg1 = (Dali::Renderer *)jarg1;
26993   if (!arg1) {
26994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26995     return 0;
26996   }
26997   {
26998     try {
26999       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27000     } catch (std::out_of_range& e) {
27001       {
27002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27003       };
27004     } catch (std::exception& e) {
27005       {
27006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27007       };
27008     } catch (Dali::DaliException e) {
27009       {
27010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27011       };
27012     } catch (...) {
27013       {
27014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27015       };
27016     }
27017   }
27018
27019   jresult = (void *)result;
27020   return jresult;
27021 }
27022
27023
27024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27025   void * jresult ;
27026   Dali::BaseHandle arg1 ;
27027   Dali::BaseHandle *argp1 ;
27028   Dali::Renderer result;
27029
27030   argp1 = (Dali::BaseHandle *)jarg1;
27031   if (!argp1) {
27032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27033     return 0;
27034   }
27035   arg1 = *argp1;
27036   {
27037     try {
27038       result = Dali::Renderer::DownCast(arg1);
27039     } catch (std::out_of_range& e) {
27040       {
27041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27042       };
27043     } catch (std::exception& e) {
27044       {
27045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27046       };
27047     } catch (Dali::DaliException e) {
27048       {
27049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27050       };
27051     } catch (...) {
27052       {
27053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27054       };
27055     }
27056   }
27057
27058   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27059   return jresult;
27060 }
27061
27062
27063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27064   void * jresult ;
27065   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27066   Dali::Renderer *arg2 = 0 ;
27067   Dali::Renderer *result = 0 ;
27068
27069   arg1 = (Dali::Renderer *)jarg1;
27070   arg2 = (Dali::Renderer *)jarg2;
27071   if (!arg2) {
27072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27073     return 0;
27074   }
27075   {
27076     try {
27077       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27078     } catch (std::out_of_range& e) {
27079       {
27080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27081       };
27082     } catch (std::exception& e) {
27083       {
27084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27085       };
27086     } catch (Dali::DaliException e) {
27087       {
27088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27089       };
27090     } catch (...) {
27091       {
27092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27093       };
27094     }
27095   }
27096
27097   jresult = (void *)result;
27098   return jresult;
27099 }
27100
27101
27102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27103   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27104   Dali::Geometry *arg2 = 0 ;
27105
27106   arg1 = (Dali::Renderer *)jarg1;
27107   arg2 = (Dali::Geometry *)jarg2;
27108   if (!arg2) {
27109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27110     return ;
27111   }
27112   {
27113     try {
27114       (arg1)->SetGeometry(*arg2);
27115     } catch (std::out_of_range& e) {
27116       {
27117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27118       };
27119     } catch (std::exception& e) {
27120       {
27121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27122       };
27123     } catch (Dali::DaliException e) {
27124       {
27125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27126       };
27127     } catch (...) {
27128       {
27129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27130       };
27131     }
27132   }
27133
27134 }
27135
27136
27137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27138   void * jresult ;
27139   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27140   Dali::Geometry result;
27141
27142   arg1 = (Dali::Renderer *)jarg1;
27143   {
27144     try {
27145       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27146     } catch (std::out_of_range& e) {
27147       {
27148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27149       };
27150     } catch (std::exception& e) {
27151       {
27152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27153       };
27154     } catch (Dali::DaliException e) {
27155       {
27156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27157       };
27158     } catch (...) {
27159       {
27160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27161       };
27162     }
27163   }
27164
27165   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27166   return jresult;
27167 }
27168
27169
27170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27171   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27172   int arg2 ;
27173   int arg3 ;
27174
27175   arg1 = (Dali::Renderer *)jarg1;
27176   arg2 = (int)jarg2;
27177   arg3 = (int)jarg3;
27178   {
27179     try {
27180       (arg1)->SetIndexRange(arg2,arg3);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27188       };
27189     } catch (Dali::DaliException e) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27192       };
27193     } catch (...) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27196       };
27197     }
27198   }
27199
27200 }
27201
27202
27203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27204   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27205   Dali::TextureSet *arg2 = 0 ;
27206
27207   arg1 = (Dali::Renderer *)jarg1;
27208   arg2 = (Dali::TextureSet *)jarg2;
27209   if (!arg2) {
27210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27211     return ;
27212   }
27213   {
27214     try {
27215       (arg1)->SetTextures(*arg2);
27216     } catch (std::out_of_range& e) {
27217       {
27218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27219       };
27220     } catch (std::exception& e) {
27221       {
27222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27223       };
27224     } catch (Dali::DaliException e) {
27225       {
27226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27227       };
27228     } catch (...) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27231       };
27232     }
27233   }
27234
27235 }
27236
27237
27238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27239   void * jresult ;
27240   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27241   Dali::TextureSet result;
27242
27243   arg1 = (Dali::Renderer *)jarg1;
27244   {
27245     try {
27246       result = ((Dali::Renderer const *)arg1)->GetTextures();
27247     } catch (std::out_of_range& e) {
27248       {
27249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27250       };
27251     } catch (std::exception& e) {
27252       {
27253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27254       };
27255     } catch (Dali::DaliException e) {
27256       {
27257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27258       };
27259     } catch (...) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27262       };
27263     }
27264   }
27265
27266   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27267   return jresult;
27268 }
27269
27270
27271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27272   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27273   Dali::Shader *arg2 = 0 ;
27274
27275   arg1 = (Dali::Renderer *)jarg1;
27276   arg2 = (Dali::Shader *)jarg2;
27277   if (!arg2) {
27278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27279     return ;
27280   }
27281   {
27282     try {
27283       (arg1)->SetShader(*arg2);
27284     } catch (std::out_of_range& e) {
27285       {
27286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27287       };
27288     } catch (std::exception& e) {
27289       {
27290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27291       };
27292     } catch (Dali::DaliException e) {
27293       {
27294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27295       };
27296     } catch (...) {
27297       {
27298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27299       };
27300     }
27301   }
27302
27303 }
27304
27305
27306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27307   void * jresult ;
27308   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27309   Dali::Shader result;
27310
27311   arg1 = (Dali::Renderer *)jarg1;
27312   {
27313     try {
27314       result = ((Dali::Renderer const *)arg1)->GetShader();
27315     } catch (std::out_of_range& e) {
27316       {
27317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27318       };
27319     } catch (std::exception& e) {
27320       {
27321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (Dali::DaliException e) {
27324       {
27325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27326       };
27327     } catch (...) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27330       };
27331     }
27332   }
27333
27334   jresult = new Dali::Shader((const Dali::Shader &)result);
27335   return jresult;
27336 }
27337
27338
27339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27340   void * jresult ;
27341   Dali::FrameBuffer::Attachment *result = 0 ;
27342
27343   {
27344     try {
27345       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27346     } catch (std::out_of_range& e) {
27347       {
27348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27349       };
27350     } catch (std::exception& e) {
27351       {
27352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27353       };
27354     } catch (Dali::DaliException e) {
27355       {
27356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27357       };
27358     } catch (...) {
27359       {
27360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27361       };
27362     }
27363   }
27364
27365   jresult = (void *)result;
27366   return jresult;
27367 }
27368
27369
27370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27371   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27372
27373   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27374   {
27375     try {
27376       delete arg1;
27377     } catch (std::out_of_range& e) {
27378       {
27379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27380       };
27381     } catch (std::exception& e) {
27382       {
27383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27384       };
27385     } catch (Dali::DaliException e) {
27386       {
27387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27388       };
27389     } catch (...) {
27390       {
27391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27392       };
27393     }
27394   }
27395
27396 }
27397
27398
27399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27400   void * jresult ;
27401   unsigned int arg1 ;
27402   unsigned int arg2 ;
27403   unsigned int arg3 ;
27404   Dali::FrameBuffer result;
27405
27406   arg1 = (unsigned int)jarg1;
27407   arg2 = (unsigned int)jarg2;
27408   arg3 = (unsigned int)jarg3;
27409   {
27410     try {
27411       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27412     } catch (std::out_of_range& e) {
27413       {
27414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27415       };
27416     } catch (std::exception& e) {
27417       {
27418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27419       };
27420     } catch (Dali::DaliException e) {
27421       {
27422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27423       };
27424     } catch (...) {
27425       {
27426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27427       };
27428     }
27429   }
27430
27431   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27437   void * jresult ;
27438   Dali::FrameBuffer *result = 0 ;
27439
27440   {
27441     try {
27442       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27443     } catch (std::out_of_range& e) {
27444       {
27445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27446       };
27447     } catch (std::exception& e) {
27448       {
27449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27450       };
27451     } catch (Dali::DaliException e) {
27452       {
27453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27454       };
27455     } catch (...) {
27456       {
27457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27458       };
27459     }
27460   }
27461
27462   jresult = (void *)result;
27463   return jresult;
27464 }
27465
27466
27467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27468   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27469
27470   arg1 = (Dali::FrameBuffer *)jarg1;
27471   {
27472     try {
27473       delete arg1;
27474     } catch (std::out_of_range& e) {
27475       {
27476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27477       };
27478     } catch (std::exception& e) {
27479       {
27480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27481       };
27482     } catch (Dali::DaliException e) {
27483       {
27484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27485       };
27486     } catch (...) {
27487       {
27488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27489       };
27490     }
27491   }
27492
27493 }
27494
27495
27496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27497   void * jresult ;
27498   Dali::FrameBuffer *arg1 = 0 ;
27499   Dali::FrameBuffer *result = 0 ;
27500
27501   arg1 = (Dali::FrameBuffer *)jarg1;
27502   if (!arg1) {
27503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27504     return 0;
27505   }
27506   {
27507     try {
27508       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27509     } catch (std::out_of_range& e) {
27510       {
27511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27512       };
27513     } catch (std::exception& e) {
27514       {
27515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27516       };
27517     } catch (Dali::DaliException e) {
27518       {
27519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27520       };
27521     } catch (...) {
27522       {
27523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27524       };
27525     }
27526   }
27527
27528   jresult = (void *)result;
27529   return jresult;
27530 }
27531
27532
27533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27534   void * jresult ;
27535   Dali::BaseHandle arg1 ;
27536   Dali::BaseHandle *argp1 ;
27537   Dali::FrameBuffer result;
27538
27539   argp1 = (Dali::BaseHandle *)jarg1;
27540   if (!argp1) {
27541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27542     return 0;
27543   }
27544   arg1 = *argp1;
27545   {
27546     try {
27547       result = Dali::FrameBuffer::DownCast(arg1);
27548     } catch (std::out_of_range& e) {
27549       {
27550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27551       };
27552     } catch (std::exception& e) {
27553       {
27554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27555       };
27556     } catch (Dali::DaliException e) {
27557       {
27558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27559       };
27560     } catch (...) {
27561       {
27562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27563       };
27564     }
27565   }
27566
27567   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27568   return jresult;
27569 }
27570
27571
27572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27573   void * jresult ;
27574   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27575   Dali::FrameBuffer *arg2 = 0 ;
27576   Dali::FrameBuffer *result = 0 ;
27577
27578   arg1 = (Dali::FrameBuffer *)jarg1;
27579   arg2 = (Dali::FrameBuffer *)jarg2;
27580   if (!arg2) {
27581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27582     return 0;
27583   }
27584   {
27585     try {
27586       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27587     } catch (std::out_of_range& e) {
27588       {
27589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27590       };
27591     } catch (std::exception& e) {
27592       {
27593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27594       };
27595     } catch (Dali::DaliException e) {
27596       {
27597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27598       };
27599     } catch (...) {
27600       {
27601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27602       };
27603     }
27604   }
27605
27606   jresult = (void *)result;
27607   return jresult;
27608 }
27609
27610
27611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27612   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27613   Dali::Texture *arg2 = 0 ;
27614
27615   arg1 = (Dali::FrameBuffer *)jarg1;
27616   arg2 = (Dali::Texture *)jarg2;
27617   if (!arg2) {
27618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27619     return ;
27620   }
27621   {
27622     try {
27623       (arg1)->AttachColorTexture(*arg2);
27624     } catch (std::out_of_range& e) {
27625       {
27626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27627       };
27628     } catch (std::exception& e) {
27629       {
27630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27631       };
27632     } catch (Dali::DaliException e) {
27633       {
27634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27635       };
27636     } catch (...) {
27637       {
27638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27639       };
27640     }
27641   }
27642
27643 }
27644
27645
27646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27647   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27648   Dali::Texture *arg2 = 0 ;
27649   unsigned int arg3 ;
27650   unsigned int arg4 ;
27651
27652   arg1 = (Dali::FrameBuffer *)jarg1;
27653   arg2 = (Dali::Texture *)jarg2;
27654   if (!arg2) {
27655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27656     return ;
27657   }
27658   arg3 = (unsigned int)jarg3;
27659   arg4 = (unsigned int)jarg4;
27660   {
27661     try {
27662       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27663     } catch (std::out_of_range& e) {
27664       {
27665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27666       };
27667     } catch (std::exception& e) {
27668       {
27669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27670       };
27671     } catch (Dali::DaliException e) {
27672       {
27673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27674       };
27675     } catch (...) {
27676       {
27677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27678       };
27679     }
27680   }
27681
27682 }
27683
27684
27685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27686   void * jresult ;
27687   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27688   Dali::Texture result;
27689
27690   arg1 = (Dali::FrameBuffer *)jarg1;
27691   {
27692     try {
27693       result = (arg1)->GetColorTexture();
27694     } catch (std::out_of_range& e) {
27695       {
27696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27697       };
27698     } catch (std::exception& e) {
27699       {
27700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27701       };
27702     } catch (Dali::DaliException e) {
27703       {
27704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27705       };
27706     } catch (...) {
27707       {
27708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27709       };
27710     }
27711   }
27712
27713   jresult = new Dali::Texture((const Dali::Texture &)result);
27714   return jresult;
27715 }
27716
27717
27718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27719   void * jresult ;
27720   Dali::RenderTaskList *result = 0 ;
27721
27722   {
27723     try {
27724       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27725     } catch (std::out_of_range& e) {
27726       {
27727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27728       };
27729     } catch (std::exception& e) {
27730       {
27731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27732       };
27733     } catch (Dali::DaliException e) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27736       };
27737     } catch (...) {
27738       {
27739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27740       };
27741     }
27742   }
27743
27744   jresult = (void *)result;
27745   return jresult;
27746 }
27747
27748
27749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27750   void * jresult ;
27751   Dali::BaseHandle arg1 ;
27752   Dali::BaseHandle *argp1 ;
27753   Dali::RenderTaskList result;
27754
27755   argp1 = (Dali::BaseHandle *)jarg1;
27756   if (!argp1) {
27757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27758     return 0;
27759   }
27760   arg1 = *argp1;
27761   {
27762     try {
27763       result = Dali::RenderTaskList::DownCast(arg1);
27764     } catch (std::out_of_range& e) {
27765       {
27766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27767       };
27768     } catch (std::exception& e) {
27769       {
27770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27771       };
27772     } catch (Dali::DaliException e) {
27773       {
27774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27775       };
27776     } catch (...) {
27777       {
27778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27779       };
27780     }
27781   }
27782
27783   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27784   return jresult;
27785 }
27786
27787
27788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27789   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27790
27791   arg1 = (Dali::RenderTaskList *)jarg1;
27792   {
27793     try {
27794       delete arg1;
27795     } catch (std::out_of_range& e) {
27796       {
27797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27798       };
27799     } catch (std::exception& e) {
27800       {
27801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27802       };
27803     } catch (Dali::DaliException e) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27806       };
27807     } catch (...) {
27808       {
27809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27810       };
27811     }
27812   }
27813
27814 }
27815
27816
27817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27818   void * jresult ;
27819   Dali::RenderTaskList *arg1 = 0 ;
27820   Dali::RenderTaskList *result = 0 ;
27821
27822   arg1 = (Dali::RenderTaskList *)jarg1;
27823   if (!arg1) {
27824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27825     return 0;
27826   }
27827   {
27828     try {
27829       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27830     } catch (std::out_of_range& e) {
27831       {
27832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27833       };
27834     } catch (std::exception& e) {
27835       {
27836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27837       };
27838     } catch (Dali::DaliException e) {
27839       {
27840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27841       };
27842     } catch (...) {
27843       {
27844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27845       };
27846     }
27847   }
27848
27849   jresult = (void *)result;
27850   return jresult;
27851 }
27852
27853
27854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27855   void * jresult ;
27856   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27857   Dali::RenderTaskList *arg2 = 0 ;
27858   Dali::RenderTaskList *result = 0 ;
27859
27860   arg1 = (Dali::RenderTaskList *)jarg1;
27861   arg2 = (Dali::RenderTaskList *)jarg2;
27862   if (!arg2) {
27863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27864     return 0;
27865   }
27866   {
27867     try {
27868       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27869     } catch (std::out_of_range& e) {
27870       {
27871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27872       };
27873     } catch (std::exception& e) {
27874       {
27875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27876       };
27877     } catch (Dali::DaliException e) {
27878       {
27879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27880       };
27881     } catch (...) {
27882       {
27883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27884       };
27885     }
27886   }
27887
27888   jresult = (void *)result;
27889   return jresult;
27890 }
27891
27892
27893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27894   void * jresult ;
27895   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27896   Dali::RenderTask result;
27897
27898   arg1 = (Dali::RenderTaskList *)jarg1;
27899   {
27900     try {
27901       result = (arg1)->CreateTask();
27902     } catch (std::out_of_range& e) {
27903       {
27904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27905       };
27906     } catch (std::exception& e) {
27907       {
27908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27909       };
27910     } catch (Dali::DaliException e) {
27911       {
27912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27913       };
27914     } catch (...) {
27915       {
27916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27917       };
27918     }
27919   }
27920
27921   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27927   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27928   Dali::RenderTask arg2 ;
27929   Dali::RenderTask *argp2 ;
27930
27931   arg1 = (Dali::RenderTaskList *)jarg1;
27932   argp2 = (Dali::RenderTask *)jarg2;
27933   if (!argp2) {
27934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27935     return ;
27936   }
27937   arg2 = *argp2;
27938   {
27939     try {
27940       (arg1)->RemoveTask(arg2);
27941     } catch (std::out_of_range& e) {
27942       {
27943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27944       };
27945     } catch (std::exception& e) {
27946       {
27947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27948       };
27949     } catch (Dali::DaliException e) {
27950       {
27951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27952       };
27953     } catch (...) {
27954       {
27955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27956       };
27957     }
27958   }
27959
27960 }
27961
27962
27963 //// ===============================================end part 1 =================
27964
27965 //// ========================= part 2 ===============================
27966
27967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27968   unsigned int jresult ;
27969   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27970   unsigned int result;
27971
27972   arg1 = (Dali::RenderTaskList *)jarg1;
27973   {
27974     try {
27975       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27976     } catch (std::out_of_range& e) {
27977       {
27978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27979       };
27980     } catch (std::exception& e) {
27981       {
27982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27983       };
27984     } catch (Dali::DaliException e) {
27985       {
27986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27987       };
27988     } catch (...) {
27989       {
27990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27991       };
27992     }
27993   }
27994
27995   jresult = result;
27996   return jresult;
27997 }
27998
27999
28000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28001   void * jresult ;
28002   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28003   unsigned int arg2 ;
28004   Dali::RenderTask result;
28005
28006   arg1 = (Dali::RenderTaskList *)jarg1;
28007   arg2 = (unsigned int)jarg2;
28008   {
28009     try {
28010       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28011     } catch (std::out_of_range& e) {
28012       {
28013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28014       };
28015     } catch (std::exception& e) {
28016       {
28017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28018       };
28019     } catch (Dali::DaliException e) {
28020       {
28021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28022       };
28023     } catch (...) {
28024       {
28025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28026       };
28027     }
28028   }
28029
28030   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28031   return jresult;
28032 }
28033
28034
28035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28036   int jresult ;
28037   int result;
28038
28039   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28040   jresult = (int)result;
28041   return jresult;
28042 }
28043
28044
28045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28046   int jresult ;
28047   int result;
28048
28049   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28050   jresult = (int)result;
28051   return jresult;
28052 }
28053
28054
28055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28056   int jresult ;
28057   int result;
28058
28059   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28060   jresult = (int)result;
28061   return jresult;
28062 }
28063
28064
28065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28066   int jresult ;
28067   int result;
28068
28069   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28070   jresult = (int)result;
28071   return jresult;
28072 }
28073
28074
28075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28076   void * jresult ;
28077   Dali::RenderTask::Property *result = 0 ;
28078
28079   {
28080     try {
28081       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28082     } catch (std::out_of_range& e) {
28083       {
28084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28085       };
28086     } catch (std::exception& e) {
28087       {
28088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28089       };
28090     } catch (Dali::DaliException e) {
28091       {
28092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28093       };
28094     } catch (...) {
28095       {
28096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28097       };
28098     }
28099   }
28100
28101   jresult = (void *)result;
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28107   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28108
28109   arg1 = (Dali::RenderTask::Property *)jarg1;
28110   {
28111     try {
28112       delete arg1;
28113     } catch (std::out_of_range& e) {
28114       {
28115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28116       };
28117     } catch (std::exception& e) {
28118       {
28119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28120       };
28121     } catch (Dali::DaliException e) {
28122       {
28123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28124       };
28125     } catch (...) {
28126       {
28127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28128       };
28129     }
28130   }
28131
28132 }
28133
28134
28135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28136   void * jresult ;
28137   bool (*result)(Dali::Vector2 &) = 0 ;
28138
28139   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28140   jresult = (void *)result;
28141   return jresult;
28142 }
28143
28144
28145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28146   void * jresult ;
28147   bool (*result)(Dali::Vector2 &) = 0 ;
28148
28149   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28150   jresult = (void *)result;
28151   return jresult;
28152 }
28153
28154
28155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28156   unsigned int jresult ;
28157   bool result;
28158
28159   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28160   jresult = result;
28161   return jresult;
28162 }
28163
28164
28165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28166   unsigned int jresult ;
28167   bool result;
28168
28169   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28170   jresult = result;
28171   return jresult;
28172 }
28173
28174
28175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28176   void * jresult ;
28177   Dali::Vector4 *result = 0 ;
28178
28179   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28180   jresult = (void *)result;
28181   return jresult;
28182 }
28183
28184
28185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28186   unsigned int jresult ;
28187   bool result;
28188
28189   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28190   jresult = result;
28191   return jresult;
28192 }
28193
28194
28195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28196   unsigned int jresult ;
28197   bool result;
28198
28199   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28200   jresult = result;
28201   return jresult;
28202 }
28203
28204
28205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28206   unsigned int jresult ;
28207   unsigned int result;
28208
28209   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28210   jresult = result;
28211   return jresult;
28212 }
28213
28214
28215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28216   void * jresult ;
28217   Dali::RenderTask *result = 0 ;
28218
28219   {
28220     try {
28221       result = (Dali::RenderTask *)new Dali::RenderTask();
28222     } catch (std::out_of_range& e) {
28223       {
28224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28225       };
28226     } catch (std::exception& e) {
28227       {
28228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28229       };
28230     } catch (Dali::DaliException e) {
28231       {
28232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28233       };
28234     } catch (...) {
28235       {
28236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28237       };
28238     }
28239   }
28240
28241   jresult = (void *)result;
28242   return jresult;
28243 }
28244
28245
28246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28247   void * jresult ;
28248   Dali::BaseHandle arg1 ;
28249   Dali::BaseHandle *argp1 ;
28250   Dali::RenderTask result;
28251
28252   argp1 = (Dali::BaseHandle *)jarg1;
28253   if (!argp1) {
28254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28255     return 0;
28256   }
28257   arg1 = *argp1;
28258   {
28259     try {
28260       result = Dali::RenderTask::DownCast(arg1);
28261     } catch (std::out_of_range& e) {
28262       {
28263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28264       };
28265     } catch (std::exception& e) {
28266       {
28267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28268       };
28269     } catch (Dali::DaliException e) {
28270       {
28271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28272       };
28273     } catch (...) {
28274       {
28275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28276       };
28277     }
28278   }
28279
28280   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28281   return jresult;
28282 }
28283
28284
28285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28286   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28287
28288   arg1 = (Dali::RenderTask *)jarg1;
28289   {
28290     try {
28291       delete arg1;
28292     } catch (std::out_of_range& e) {
28293       {
28294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28295       };
28296     } catch (std::exception& e) {
28297       {
28298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28299       };
28300     } catch (Dali::DaliException e) {
28301       {
28302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28303       };
28304     } catch (...) {
28305       {
28306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28307       };
28308     }
28309   }
28310
28311 }
28312
28313
28314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28315   void * jresult ;
28316   Dali::RenderTask *arg1 = 0 ;
28317   Dali::RenderTask *result = 0 ;
28318
28319   arg1 = (Dali::RenderTask *)jarg1;
28320   if (!arg1) {
28321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28322     return 0;
28323   }
28324   {
28325     try {
28326       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28327     } catch (std::out_of_range& e) {
28328       {
28329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28330       };
28331     } catch (std::exception& e) {
28332       {
28333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28334       };
28335     } catch (Dali::DaliException e) {
28336       {
28337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28338       };
28339     } catch (...) {
28340       {
28341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28342       };
28343     }
28344   }
28345
28346   jresult = (void *)result;
28347   return jresult;
28348 }
28349
28350
28351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28352   void * jresult ;
28353   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28354   Dali::RenderTask *arg2 = 0 ;
28355   Dali::RenderTask *result = 0 ;
28356
28357   arg1 = (Dali::RenderTask *)jarg1;
28358   arg2 = (Dali::RenderTask *)jarg2;
28359   if (!arg2) {
28360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28361     return 0;
28362   }
28363   {
28364     try {
28365       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28366     } catch (std::out_of_range& e) {
28367       {
28368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28369       };
28370     } catch (std::exception& e) {
28371       {
28372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28373       };
28374     } catch (Dali::DaliException e) {
28375       {
28376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28377       };
28378     } catch (...) {
28379       {
28380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28381       };
28382     }
28383   }
28384
28385   jresult = (void *)result;
28386   return jresult;
28387 }
28388
28389
28390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28391   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28392   Dali::Actor arg2 ;
28393   Dali::Actor *argp2 ;
28394
28395   arg1 = (Dali::RenderTask *)jarg1;
28396   argp2 = (Dali::Actor *)jarg2;
28397   if (!argp2) {
28398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28399     return ;
28400   }
28401   arg2 = *argp2;
28402   {
28403     try {
28404       (arg1)->SetSourceActor(arg2);
28405     } catch (std::out_of_range& e) {
28406       {
28407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28408       };
28409     } catch (std::exception& e) {
28410       {
28411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28412       };
28413     } catch (Dali::DaliException e) {
28414       {
28415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28416       };
28417     } catch (...) {
28418       {
28419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28420       };
28421     }
28422   }
28423
28424 }
28425
28426
28427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28428   void * jresult ;
28429   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28430   Dali::Actor result;
28431
28432   arg1 = (Dali::RenderTask *)jarg1;
28433   {
28434     try {
28435       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28436     } catch (std::out_of_range& e) {
28437       {
28438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28439       };
28440     } catch (std::exception& e) {
28441       {
28442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28443       };
28444     } catch (Dali::DaliException e) {
28445       {
28446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28447       };
28448     } catch (...) {
28449       {
28450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28451       };
28452     }
28453   }
28454
28455   jresult = new Dali::Actor((const Dali::Actor &)result);
28456   return jresult;
28457 }
28458
28459
28460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28461   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28462   bool arg2 ;
28463
28464   arg1 = (Dali::RenderTask *)jarg1;
28465   arg2 = jarg2 ? true : false;
28466   {
28467     try {
28468       (arg1)->SetExclusive(arg2);
28469     } catch (std::out_of_range& e) {
28470       {
28471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28472       };
28473     } catch (std::exception& e) {
28474       {
28475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28476       };
28477     } catch (Dali::DaliException e) {
28478       {
28479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28480       };
28481     } catch (...) {
28482       {
28483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28484       };
28485     }
28486   }
28487
28488 }
28489
28490
28491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28492   unsigned int jresult ;
28493   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28494   bool result;
28495
28496   arg1 = (Dali::RenderTask *)jarg1;
28497   {
28498     try {
28499       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28500     } catch (std::out_of_range& e) {
28501       {
28502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28503       };
28504     } catch (std::exception& e) {
28505       {
28506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28507       };
28508     } catch (Dali::DaliException e) {
28509       {
28510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28511       };
28512     } catch (...) {
28513       {
28514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28515       };
28516     }
28517   }
28518
28519   jresult = result;
28520   return jresult;
28521 }
28522
28523
28524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28525   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28526   bool arg2 ;
28527
28528   arg1 = (Dali::RenderTask *)jarg1;
28529   arg2 = jarg2 ? true : false;
28530   {
28531     try {
28532       (arg1)->SetInputEnabled(arg2);
28533     } catch (std::out_of_range& e) {
28534       {
28535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28536       };
28537     } catch (std::exception& e) {
28538       {
28539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28540       };
28541     } catch (Dali::DaliException e) {
28542       {
28543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28544       };
28545     } catch (...) {
28546       {
28547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28548       };
28549     }
28550   }
28551
28552 }
28553
28554
28555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28556   unsigned int jresult ;
28557   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28558   bool result;
28559
28560   arg1 = (Dali::RenderTask *)jarg1;
28561   {
28562     try {
28563       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28564     } catch (std::out_of_range& e) {
28565       {
28566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28567       };
28568     } catch (std::exception& e) {
28569       {
28570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28571       };
28572     } catch (Dali::DaliException e) {
28573       {
28574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28575       };
28576     } catch (...) {
28577       {
28578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28579       };
28580     }
28581   }
28582
28583   jresult = result;
28584   return jresult;
28585 }
28586
28587
28588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28589   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28590   Dali::CameraActor arg2 ;
28591   Dali::CameraActor *argp2 ;
28592
28593   arg1 = (Dali::RenderTask *)jarg1;
28594   argp2 = (Dali::CameraActor *)jarg2;
28595   if (!argp2) {
28596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28597     return ;
28598   }
28599   arg2 = *argp2;
28600   {
28601     try {
28602       (arg1)->SetCameraActor(arg2);
28603     } catch (std::out_of_range& e) {
28604       {
28605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28606       };
28607     } catch (std::exception& e) {
28608       {
28609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28610       };
28611     } catch (Dali::DaliException e) {
28612       {
28613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28614       };
28615     } catch (...) {
28616       {
28617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28618       };
28619     }
28620   }
28621
28622 }
28623
28624
28625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28626   void * jresult ;
28627   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28628   Dali::CameraActor result;
28629
28630   arg1 = (Dali::RenderTask *)jarg1;
28631   {
28632     try {
28633       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28634     } catch (std::out_of_range& e) {
28635       {
28636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28637       };
28638     } catch (std::exception& e) {
28639       {
28640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28641       };
28642     } catch (Dali::DaliException e) {
28643       {
28644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28645       };
28646     } catch (...) {
28647       {
28648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28649       };
28650     }
28651   }
28652
28653   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28654   return jresult;
28655 }
28656
28657
28658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28659   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28660   Dali::FrameBufferImage arg2 ;
28661   Dali::FrameBufferImage *argp2 ;
28662
28663   arg1 = (Dali::RenderTask *)jarg1;
28664   argp2 = (Dali::FrameBufferImage *)jarg2;
28665   if (!argp2) {
28666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28667     return ;
28668   }
28669   arg2 = *argp2;
28670   {
28671     try {
28672       (arg1)->SetTargetFrameBuffer(arg2);
28673     } catch (std::out_of_range& e) {
28674       {
28675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28676       };
28677     } catch (std::exception& e) {
28678       {
28679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28680       };
28681     } catch (Dali::DaliException e) {
28682       {
28683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28684       };
28685     } catch (...) {
28686       {
28687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28688       };
28689     }
28690   }
28691
28692 }
28693
28694
28695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28696   void * jresult ;
28697   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28698   Dali::FrameBufferImage result;
28699
28700   arg1 = (Dali::RenderTask *)jarg1;
28701   {
28702     try {
28703       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28704     } catch (std::out_of_range& e) {
28705       {
28706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28707       };
28708     } catch (std::exception& e) {
28709       {
28710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28711       };
28712     } catch (Dali::DaliException e) {
28713       {
28714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28715       };
28716     } catch (...) {
28717       {
28718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28719       };
28720     }
28721   }
28722
28723   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28724   return jresult;
28725 }
28726
28727
28728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28729   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28730   Dali::FrameBuffer arg2 ;
28731   Dali::FrameBuffer *argp2 ;
28732
28733   arg1 = (Dali::RenderTask *)jarg1;
28734   argp2 = (Dali::FrameBuffer *)jarg2;
28735   if (!argp2) {
28736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28737     return ;
28738   }
28739   arg2 = *argp2;
28740   {
28741     try {
28742       (arg1)->SetFrameBuffer(arg2);
28743     } catch (std::out_of_range& e) {
28744       {
28745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28746       };
28747     } catch (std::exception& e) {
28748       {
28749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28750       };
28751     } catch (Dali::DaliException e) {
28752       {
28753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28754       };
28755     } catch (...) {
28756       {
28757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28758       };
28759     }
28760   }
28761
28762 }
28763
28764
28765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28766   void * jresult ;
28767   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28768   Dali::FrameBuffer result;
28769
28770   arg1 = (Dali::RenderTask *)jarg1;
28771   {
28772     try {
28773       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28774     } catch (std::out_of_range& e) {
28775       {
28776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28777       };
28778     } catch (std::exception& e) {
28779       {
28780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28781       };
28782     } catch (Dali::DaliException e) {
28783       {
28784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28785       };
28786     } catch (...) {
28787       {
28788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28789       };
28790     }
28791   }
28792
28793   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28794   return jresult;
28795 }
28796
28797
28798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28799   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28800   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28801
28802   arg1 = (Dali::RenderTask *)jarg1;
28803   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28804   {
28805     try {
28806       (arg1)->SetScreenToFrameBufferFunction(arg2);
28807     } catch (std::out_of_range& e) {
28808       {
28809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28810       };
28811     } catch (std::exception& e) {
28812       {
28813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28814       };
28815     } catch (Dali::DaliException e) {
28816       {
28817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28818       };
28819     } catch (...) {
28820       {
28821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28822       };
28823     }
28824   }
28825
28826 }
28827
28828
28829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28830   void * jresult ;
28831   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28832   Dali::RenderTask::ScreenToFrameBufferFunction result;
28833
28834   arg1 = (Dali::RenderTask *)jarg1;
28835   {
28836     try {
28837       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28838     } catch (std::out_of_range& e) {
28839       {
28840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28841       };
28842     } catch (std::exception& e) {
28843       {
28844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28845       };
28846     } catch (Dali::DaliException e) {
28847       {
28848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28849       };
28850     } catch (...) {
28851       {
28852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28853       };
28854     }
28855   }
28856
28857   jresult = (void *)result;
28858   return jresult;
28859 }
28860
28861
28862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28864   Dali::Actor arg2 ;
28865   Dali::Actor *argp2 ;
28866
28867   arg1 = (Dali::RenderTask *)jarg1;
28868   argp2 = (Dali::Actor *)jarg2;
28869   if (!argp2) {
28870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28871     return ;
28872   }
28873   arg2 = *argp2;
28874   {
28875     try {
28876       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28877     } catch (std::out_of_range& e) {
28878       {
28879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28880       };
28881     } catch (std::exception& e) {
28882       {
28883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28884       };
28885     } catch (Dali::DaliException e) {
28886       {
28887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28888       };
28889     } catch (...) {
28890       {
28891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28892       };
28893     }
28894   }
28895
28896 }
28897
28898
28899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28900   void * jresult ;
28901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28902   Dali::Actor result;
28903
28904   arg1 = (Dali::RenderTask *)jarg1;
28905   {
28906     try {
28907       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28908     } catch (std::out_of_range& e) {
28909       {
28910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28911       };
28912     } catch (std::exception& e) {
28913       {
28914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28915       };
28916     } catch (Dali::DaliException e) {
28917       {
28918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28919       };
28920     } catch (...) {
28921       {
28922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28923       };
28924     }
28925   }
28926
28927   jresult = new Dali::Actor((const Dali::Actor &)result);
28928   return jresult;
28929 }
28930
28931
28932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28934   Dali::Vector2 arg2 ;
28935   Dali::Vector2 *argp2 ;
28936
28937   arg1 = (Dali::RenderTask *)jarg1;
28938   argp2 = (Dali::Vector2 *)jarg2;
28939   if (!argp2) {
28940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28941     return ;
28942   }
28943   arg2 = *argp2;
28944   {
28945     try {
28946       (arg1)->SetViewportPosition(arg2);
28947     } catch (std::out_of_range& e) {
28948       {
28949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28950       };
28951     } catch (std::exception& e) {
28952       {
28953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28954       };
28955     } catch (Dali::DaliException e) {
28956       {
28957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28958       };
28959     } catch (...) {
28960       {
28961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28962       };
28963     }
28964   }
28965
28966 }
28967
28968
28969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28970   void * jresult ;
28971   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28972   Dali::Vector2 result;
28973
28974   arg1 = (Dali::RenderTask *)jarg1;
28975   {
28976     try {
28977       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28978     } catch (std::out_of_range& e) {
28979       {
28980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28981       };
28982     } catch (std::exception& e) {
28983       {
28984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28985       };
28986     } catch (Dali::DaliException e) {
28987       {
28988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28989       };
28990     } catch (...) {
28991       {
28992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28993       };
28994     }
28995   }
28996
28997   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28998   return jresult;
28999 }
29000
29001
29002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29003   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29004   Dali::Vector2 arg2 ;
29005   Dali::Vector2 *argp2 ;
29006
29007   arg1 = (Dali::RenderTask *)jarg1;
29008   argp2 = (Dali::Vector2 *)jarg2;
29009   if (!argp2) {
29010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29011     return ;
29012   }
29013   arg2 = *argp2;
29014   {
29015     try {
29016       (arg1)->SetViewportSize(arg2);
29017     } catch (std::out_of_range& e) {
29018       {
29019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29020       };
29021     } catch (std::exception& e) {
29022       {
29023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29024       };
29025     } catch (Dali::DaliException e) {
29026       {
29027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29028       };
29029     } catch (...) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29032       };
29033     }
29034   }
29035
29036 }
29037
29038
29039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29040   void * jresult ;
29041   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29042   Dali::Vector2 result;
29043
29044   arg1 = (Dali::RenderTask *)jarg1;
29045   {
29046     try {
29047       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29048     } catch (std::out_of_range& e) {
29049       {
29050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29051       };
29052     } catch (std::exception& e) {
29053       {
29054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29055       };
29056     } catch (Dali::DaliException e) {
29057       {
29058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29059       };
29060     } catch (...) {
29061       {
29062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29063       };
29064     }
29065   }
29066
29067   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29068   return jresult;
29069 }
29070
29071
29072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29073   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29074   Dali::Viewport arg2 ;
29075   Dali::Viewport *argp2 ;
29076
29077   arg1 = (Dali::RenderTask *)jarg1;
29078   argp2 = (Dali::Viewport *)jarg2;
29079   if (!argp2) {
29080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29081     return ;
29082   }
29083   arg2 = *argp2;
29084   {
29085     try {
29086       (arg1)->SetViewport(arg2);
29087     } catch (std::out_of_range& e) {
29088       {
29089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29090       };
29091     } catch (std::exception& e) {
29092       {
29093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29094       };
29095     } catch (Dali::DaliException e) {
29096       {
29097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29098       };
29099     } catch (...) {
29100       {
29101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29102       };
29103     }
29104   }
29105
29106 }
29107
29108
29109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29110   void * jresult ;
29111   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29112   Dali::Viewport result;
29113
29114   arg1 = (Dali::RenderTask *)jarg1;
29115   {
29116     try {
29117       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29118     } catch (std::out_of_range& e) {
29119       {
29120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29121       };
29122     } catch (std::exception& e) {
29123       {
29124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29125       };
29126     } catch (Dali::DaliException e) {
29127       {
29128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29129       };
29130     } catch (...) {
29131       {
29132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29133       };
29134     }
29135   }
29136
29137   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29138   return jresult;
29139 }
29140
29141
29142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29143   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29144   Dali::Vector4 *arg2 = 0 ;
29145
29146   arg1 = (Dali::RenderTask *)jarg1;
29147   arg2 = (Dali::Vector4 *)jarg2;
29148   if (!arg2) {
29149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29150     return ;
29151   }
29152   {
29153     try {
29154       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29155     } catch (std::out_of_range& e) {
29156       {
29157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29158       };
29159     } catch (std::exception& e) {
29160       {
29161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29162       };
29163     } catch (Dali::DaliException e) {
29164       {
29165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29166       };
29167     } catch (...) {
29168       {
29169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29170       };
29171     }
29172   }
29173
29174 }
29175
29176
29177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29178   void * jresult ;
29179   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29180   Dali::Vector4 result;
29181
29182   arg1 = (Dali::RenderTask *)jarg1;
29183   {
29184     try {
29185       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29186     } catch (std::out_of_range& e) {
29187       {
29188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29189       };
29190     } catch (std::exception& e) {
29191       {
29192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29193       };
29194     } catch (Dali::DaliException e) {
29195       {
29196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29197       };
29198     } catch (...) {
29199       {
29200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29201       };
29202     }
29203   }
29204
29205   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29206   return jresult;
29207 }
29208
29209
29210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29212   bool arg2 ;
29213
29214   arg1 = (Dali::RenderTask *)jarg1;
29215   arg2 = jarg2 ? true : false;
29216   {
29217     try {
29218       (arg1)->SetClearEnabled(arg2);
29219     } catch (std::out_of_range& e) {
29220       {
29221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29222       };
29223     } catch (std::exception& e) {
29224       {
29225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29226       };
29227     } catch (Dali::DaliException e) {
29228       {
29229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29230       };
29231     } catch (...) {
29232       {
29233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29234       };
29235     }
29236   }
29237
29238 }
29239
29240
29241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29242   unsigned int jresult ;
29243   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29244   bool result;
29245
29246   arg1 = (Dali::RenderTask *)jarg1;
29247   {
29248     try {
29249       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29250     } catch (std::out_of_range& e) {
29251       {
29252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29253       };
29254     } catch (std::exception& e) {
29255       {
29256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29257       };
29258     } catch (Dali::DaliException e) {
29259       {
29260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29261       };
29262     } catch (...) {
29263       {
29264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29265       };
29266     }
29267   }
29268
29269   jresult = result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29275   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29276   bool arg2 ;
29277
29278   arg1 = (Dali::RenderTask *)jarg1;
29279   arg2 = jarg2 ? true : false;
29280   {
29281     try {
29282       (arg1)->SetCullMode(arg2);
29283     } catch (std::out_of_range& e) {
29284       {
29285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29286       };
29287     } catch (std::exception& e) {
29288       {
29289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29290       };
29291     } catch (Dali::DaliException e) {
29292       {
29293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29294       };
29295     } catch (...) {
29296       {
29297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29298       };
29299     }
29300   }
29301
29302 }
29303
29304
29305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29306   unsigned int jresult ;
29307   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29308   bool result;
29309
29310   arg1 = (Dali::RenderTask *)jarg1;
29311   {
29312     try {
29313       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29314     } catch (std::out_of_range& e) {
29315       {
29316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29317       };
29318     } catch (std::exception& e) {
29319       {
29320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29321       };
29322     } catch (Dali::DaliException e) {
29323       {
29324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29325       };
29326     } catch (...) {
29327       {
29328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29329       };
29330     }
29331   }
29332
29333   jresult = result;
29334   return jresult;
29335 }
29336
29337
29338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29339   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29340   unsigned int arg2 ;
29341
29342   arg1 = (Dali::RenderTask *)jarg1;
29343   arg2 = (unsigned int)jarg2;
29344   {
29345     try {
29346       (arg1)->SetRefreshRate(arg2);
29347     } catch (std::out_of_range& e) {
29348       {
29349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29350       };
29351     } catch (std::exception& e) {
29352       {
29353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29354       };
29355     } catch (Dali::DaliException e) {
29356       {
29357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29358       };
29359     } catch (...) {
29360       {
29361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29362       };
29363     }
29364   }
29365
29366 }
29367
29368
29369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29370   unsigned int jresult ;
29371   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29372   unsigned int result;
29373
29374   arg1 = (Dali::RenderTask *)jarg1;
29375   {
29376     try {
29377       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29378     } catch (std::out_of_range& e) {
29379       {
29380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29381       };
29382     } catch (std::exception& e) {
29383       {
29384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29385       };
29386     } catch (Dali::DaliException e) {
29387       {
29388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29389       };
29390     } catch (...) {
29391       {
29392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29393       };
29394     }
29395   }
29396
29397   jresult = result;
29398   return jresult;
29399 }
29400
29401
29402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29403   unsigned int jresult ;
29404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29405   Dali::Vector3 *arg2 = 0 ;
29406   float *arg3 = 0 ;
29407   float *arg4 = 0 ;
29408   bool result;
29409
29410   arg1 = (Dali::RenderTask *)jarg1;
29411   arg2 = (Dali::Vector3 *)jarg2;
29412   if (!arg2) {
29413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29414     return 0;
29415   }
29416   arg3 = (float *)jarg3;
29417   arg4 = (float *)jarg4;
29418   {
29419     try {
29420       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29421     } catch (std::out_of_range& e) {
29422       {
29423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29424       };
29425     } catch (std::exception& e) {
29426       {
29427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29428       };
29429     } catch (Dali::DaliException e) {
29430       {
29431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29432       };
29433     } catch (...) {
29434       {
29435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29436       };
29437     }
29438   }
29439
29440   jresult = result;
29441   return jresult;
29442 }
29443
29444
29445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29446   unsigned int jresult ;
29447   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29448   Dali::Actor arg2 ;
29449   float arg3 ;
29450   float arg4 ;
29451   float *arg5 = 0 ;
29452   float *arg6 = 0 ;
29453   Dali::Actor *argp2 ;
29454   bool result;
29455
29456   arg1 = (Dali::RenderTask *)jarg1;
29457   argp2 = (Dali::Actor *)jarg2;
29458   if (!argp2) {
29459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29460     return 0;
29461   }
29462   arg2 = *argp2;
29463   arg3 = (float)jarg3;
29464   arg4 = (float)jarg4;
29465   arg5 = (float *)jarg5;
29466   arg6 = (float *)jarg6;
29467   {
29468     try {
29469       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29470     } catch (std::out_of_range& e) {
29471       {
29472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (std::exception& e) {
29475       {
29476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29477       };
29478     } catch (Dali::DaliException e) {
29479       {
29480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29481       };
29482     } catch (...) {
29483       {
29484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29485       };
29486     }
29487   }
29488
29489   jresult = result;
29490   return jresult;
29491 }
29492
29493
29494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29495   void * jresult ;
29496   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29497   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29498
29499   arg1 = (Dali::RenderTask *)jarg1;
29500   {
29501     try {
29502       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29503     } catch (std::out_of_range& e) {
29504       {
29505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29506       };
29507     } catch (std::exception& e) {
29508       {
29509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29510       };
29511     } catch (Dali::DaliException e) {
29512       {
29513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29514       };
29515     } catch (...) {
29516       {
29517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29518       };
29519     }
29520   }
29521
29522   jresult = (void *)result;
29523   return jresult;
29524 }
29525
29526
29527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29528   void * jresult ;
29529   int arg1 ;
29530   Dali::TouchPoint::State arg2 ;
29531   float arg3 ;
29532   float arg4 ;
29533   Dali::TouchPoint *result = 0 ;
29534
29535   arg1 = (int)jarg1;
29536   arg2 = (Dali::TouchPoint::State)jarg2;
29537   arg3 = (float)jarg3;
29538   arg4 = (float)jarg4;
29539   {
29540     try {
29541       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29542     } catch (std::out_of_range& e) {
29543       {
29544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29545       };
29546     } catch (std::exception& e) {
29547       {
29548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29549       };
29550     } catch (Dali::DaliException e) {
29551       {
29552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29553       };
29554     } catch (...) {
29555       {
29556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29557       };
29558     }
29559   }
29560
29561   jresult = (void *)result;
29562   return jresult;
29563 }
29564
29565
29566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29567   void * jresult ;
29568   int arg1 ;
29569   Dali::TouchPoint::State arg2 ;
29570   float arg3 ;
29571   float arg4 ;
29572   float arg5 ;
29573   float arg6 ;
29574   Dali::TouchPoint *result = 0 ;
29575
29576   arg1 = (int)jarg1;
29577   arg2 = (Dali::TouchPoint::State)jarg2;
29578   arg3 = (float)jarg3;
29579   arg4 = (float)jarg4;
29580   arg5 = (float)jarg5;
29581   arg6 = (float)jarg6;
29582   {
29583     try {
29584       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29585     } catch (std::out_of_range& e) {
29586       {
29587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29588       };
29589     } catch (std::exception& e) {
29590       {
29591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29592       };
29593     } catch (Dali::DaliException e) {
29594       {
29595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29596       };
29597     } catch (...) {
29598       {
29599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29600       };
29601     }
29602   }
29603
29604   jresult = (void *)result;
29605   return jresult;
29606 }
29607
29608
29609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29610   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29611
29612   arg1 = (Dali::TouchPoint *)jarg1;
29613   {
29614     try {
29615       delete arg1;
29616     } catch (std::out_of_range& e) {
29617       {
29618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29619       };
29620     } catch (std::exception& e) {
29621       {
29622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29623       };
29624     } catch (Dali::DaliException e) {
29625       {
29626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29627       };
29628     } catch (...) {
29629       {
29630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29631       };
29632     }
29633   }
29634
29635 }
29636
29637
29638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29639   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29640   int arg2 ;
29641
29642   arg1 = (Dali::TouchPoint *)jarg1;
29643   arg2 = (int)jarg2;
29644   if (arg1) (arg1)->deviceId = arg2;
29645 }
29646
29647
29648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29649   int jresult ;
29650   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29651   int result;
29652
29653   arg1 = (Dali::TouchPoint *)jarg1;
29654   result = (int) ((arg1)->deviceId);
29655   jresult = result;
29656   return jresult;
29657 }
29658
29659
29660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29661   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29662   Dali::TouchPoint::State arg2 ;
29663
29664   arg1 = (Dali::TouchPoint *)jarg1;
29665   arg2 = (Dali::TouchPoint::State)jarg2;
29666   if (arg1) (arg1)->state = arg2;
29667 }
29668
29669
29670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29671   int jresult ;
29672   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29673   Dali::TouchPoint::State result;
29674
29675   arg1 = (Dali::TouchPoint *)jarg1;
29676   result = (Dali::TouchPoint::State) ((arg1)->state);
29677   jresult = (int)result;
29678   return jresult;
29679 }
29680
29681
29682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29683   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29684   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29685
29686   arg1 = (Dali::TouchPoint *)jarg1;
29687   arg2 = (Dali::Actor *)jarg2;
29688   if (arg1) (arg1)->hitActor = *arg2;
29689 }
29690
29691
29692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29693   void * jresult ;
29694   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29695   Dali::Actor *result = 0 ;
29696
29697   arg1 = (Dali::TouchPoint *)jarg1;
29698   result = (Dali::Actor *)& ((arg1)->hitActor);
29699   jresult = (void *)result;
29700   return jresult;
29701 }
29702
29703
29704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29705   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29706   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29707
29708   arg1 = (Dali::TouchPoint *)jarg1;
29709   arg2 = (Dali::Vector2 *)jarg2;
29710   if (arg1) (arg1)->local = *arg2;
29711 }
29712
29713
29714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29715   void * jresult ;
29716   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29717   Dali::Vector2 *result = 0 ;
29718
29719   arg1 = (Dali::TouchPoint *)jarg1;
29720   result = (Dali::Vector2 *)& ((arg1)->local);
29721   jresult = (void *)result;
29722   return jresult;
29723 }
29724
29725
29726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29727   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29728   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29729
29730   arg1 = (Dali::TouchPoint *)jarg1;
29731   arg2 = (Dali::Vector2 *)jarg2;
29732   if (arg1) (arg1)->screen = *arg2;
29733 }
29734
29735
29736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29737   void * jresult ;
29738   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29739   Dali::Vector2 *result = 0 ;
29740
29741   arg1 = (Dali::TouchPoint *)jarg1;
29742   result = (Dali::Vector2 *)& ((arg1)->screen);
29743   jresult = (void *)result;
29744   return jresult;
29745 }
29746
29747
29748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29749   void * jresult ;
29750   Dali::TouchData *result = 0 ;
29751
29752   {
29753     try {
29754       result = (Dali::TouchData *)new Dali::TouchData();
29755     } catch (std::out_of_range& e) {
29756       {
29757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29758       };
29759     } catch (std::exception& e) {
29760       {
29761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29762       };
29763     } catch (Dali::DaliException e) {
29764       {
29765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29766       };
29767     } catch (...) {
29768       {
29769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29770       };
29771     }
29772   }
29773
29774   jresult = (void *)result;
29775   return jresult;
29776 }
29777
29778
29779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29780   void * jresult ;
29781   Dali::TouchData *arg1 = 0 ;
29782   Dali::TouchData *result = 0 ;
29783
29784   arg1 = (Dali::TouchData *)jarg1;
29785   if (!arg1) {
29786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29787     return 0;
29788   }
29789   {
29790     try {
29791       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29792     } catch (std::out_of_range& e) {
29793       {
29794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29795       };
29796     } catch (std::exception& e) {
29797       {
29798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29799       };
29800     } catch (Dali::DaliException e) {
29801       {
29802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29803       };
29804     } catch (...) {
29805       {
29806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29807       };
29808     }
29809   }
29810
29811   jresult = (void *)result;
29812   return jresult;
29813 }
29814
29815
29816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29817   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29818
29819   arg1 = (Dali::TouchData *)jarg1;
29820   {
29821     try {
29822       delete arg1;
29823     } catch (std::out_of_range& e) {
29824       {
29825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29826       };
29827     } catch (std::exception& e) {
29828       {
29829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29830       };
29831     } catch (Dali::DaliException e) {
29832       {
29833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29834       };
29835     } catch (...) {
29836       {
29837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29838       };
29839     }
29840   }
29841
29842 }
29843
29844
29845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29846   void * jresult ;
29847   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29848   Dali::TouchData *arg2 = 0 ;
29849   Dali::TouchData *result = 0 ;
29850
29851   arg1 = (Dali::TouchData *)jarg1;
29852   arg2 = (Dali::TouchData *)jarg2;
29853   if (!arg2) {
29854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29855     return 0;
29856   }
29857   {
29858     try {
29859       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29860     } catch (std::out_of_range& e) {
29861       {
29862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29863       };
29864     } catch (std::exception& e) {
29865       {
29866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29867       };
29868     } catch (Dali::DaliException e) {
29869       {
29870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29871       };
29872     } catch (...) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29875       };
29876     }
29877   }
29878
29879   jresult = (void *)result;
29880   return jresult;
29881 }
29882
29883
29884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29885   unsigned long jresult ;
29886   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29887   unsigned long result;
29888
29889   arg1 = (Dali::TouchData *)jarg1;
29890   {
29891     try {
29892       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29893     } catch (std::out_of_range& e) {
29894       {
29895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29896       };
29897     } catch (std::exception& e) {
29898       {
29899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29900       };
29901     } catch (Dali::DaliException e) {
29902       {
29903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29904       };
29905     } catch (...) {
29906       {
29907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29908       };
29909     }
29910   }
29911
29912   jresult = (unsigned long)result;
29913   return jresult;
29914 }
29915
29916
29917 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29918   unsigned long jresult ;
29919   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29920   std::size_t result;
29921
29922   arg1 = (Dali::TouchData *)jarg1;
29923   {
29924     try {
29925       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29926     } catch (std::out_of_range& e) {
29927       {
29928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29929       };
29930     } catch (std::exception& e) {
29931       {
29932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29933       };
29934     } catch (Dali::DaliException e) {
29935       {
29936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29937       };
29938     } catch (...) {
29939       {
29940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29941       };
29942     }
29943   }
29944
29945   jresult = (unsigned long)result;
29946   return jresult;
29947 }
29948
29949
29950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29951   int jresult ;
29952   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29953   std::size_t arg2 ;
29954   int32_t result;
29955
29956   arg1 = (Dali::TouchData *)jarg1;
29957   arg2 = (std::size_t)jarg2;
29958   {
29959     try {
29960       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29961     } catch (std::out_of_range& e) {
29962       {
29963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29964       };
29965     } catch (std::exception& e) {
29966       {
29967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29968       };
29969     } catch (Dali::DaliException e) {
29970       {
29971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29972       };
29973     } catch (...) {
29974       {
29975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29976       };
29977     }
29978   }
29979
29980   jresult = result;
29981   return jresult;
29982 }
29983
29984
29985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29986   int jresult ;
29987   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29988   std::size_t arg2 ;
29989   Dali::PointState::Type result;
29990
29991   arg1 = (Dali::TouchData *)jarg1;
29992   arg2 = (std::size_t)jarg2;
29993   {
29994     try {
29995       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29996     } catch (std::out_of_range& e) {
29997       {
29998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29999       };
30000     } catch (std::exception& e) {
30001       {
30002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30003       };
30004     } catch (Dali::DaliException e) {
30005       {
30006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30007       };
30008     } catch (...) {
30009       {
30010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30011       };
30012     }
30013   }
30014
30015   jresult = (int)result;
30016   return jresult;
30017 }
30018
30019
30020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30021   void * jresult ;
30022   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30023   std::size_t arg2 ;
30024   Dali::Actor result;
30025
30026   arg1 = (Dali::TouchData *)jarg1;
30027   arg2 = (std::size_t)jarg2;
30028   {
30029     try {
30030       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30031     } catch (std::out_of_range& e) {
30032       {
30033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30034       };
30035     } catch (std::exception& e) {
30036       {
30037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30038       };
30039     } catch (Dali::DaliException e) {
30040       {
30041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30042       };
30043     } catch (...) {
30044       {
30045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30046       };
30047     }
30048   }
30049
30050   jresult = new Dali::Actor((const Dali::Actor &)result);
30051   return jresult;
30052 }
30053
30054
30055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30056   void * jresult ;
30057   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30058   std::size_t arg2 ;
30059   Dali::Vector2 *result = 0 ;
30060
30061   arg1 = (Dali::TouchData *)jarg1;
30062   arg2 = (std::size_t)jarg2;
30063   {
30064     try {
30065       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30066     } catch (std::out_of_range& e) {
30067       {
30068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30069       };
30070     } catch (std::exception& e) {
30071       {
30072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30073       };
30074     } catch (Dali::DaliException e) {
30075       {
30076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30077       };
30078     } catch (...) {
30079       {
30080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30081       };
30082     }
30083   }
30084
30085   jresult = (void *)result;
30086   return jresult;
30087 }
30088
30089
30090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30091   void * jresult ;
30092   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30093   std::size_t arg2 ;
30094   Dali::Vector2 *result = 0 ;
30095
30096   arg1 = (Dali::TouchData *)jarg1;
30097   arg2 = (std::size_t)jarg2;
30098   {
30099     try {
30100       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30101     } catch (std::out_of_range& e) {
30102       {
30103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30104       };
30105     } catch (std::exception& e) {
30106       {
30107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30108       };
30109     } catch (Dali::DaliException e) {
30110       {
30111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30112       };
30113     } catch (...) {
30114       {
30115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30116       };
30117     }
30118   }
30119
30120   jresult = (void *)result;
30121   return jresult;
30122 }
30123
30124
30125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30126   float jresult ;
30127   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30128   std::size_t arg2 ;
30129   float result;
30130
30131   arg1 = (Dali::TouchData *)jarg1;
30132   arg2 = (std::size_t)jarg2;
30133   {
30134     try {
30135       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30136     } catch (std::out_of_range& e) {
30137       {
30138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30139       };
30140     } catch (std::exception& e) {
30141       {
30142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30143       };
30144     } catch (Dali::DaliException e) {
30145       {
30146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30147       };
30148     } catch (...) {
30149       {
30150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30151       };
30152     }
30153   }
30154
30155   jresult = result;
30156   return jresult;
30157 }
30158
30159
30160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30161   void * jresult ;
30162   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30163   std::size_t arg2 ;
30164   Dali::Vector2 *result = 0 ;
30165
30166   arg1 = (Dali::TouchData *)jarg1;
30167   arg2 = (std::size_t)jarg2;
30168   {
30169     try {
30170       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30171     } catch (std::out_of_range& e) {
30172       {
30173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30174       };
30175     } catch (std::exception& e) {
30176       {
30177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30178       };
30179     } catch (Dali::DaliException e) {
30180       {
30181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30182       };
30183     } catch (...) {
30184       {
30185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30186       };
30187     }
30188   }
30189
30190   jresult = (void *)result;
30191   return jresult;
30192 }
30193
30194
30195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30196   float jresult ;
30197   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30198   std::size_t arg2 ;
30199   float result;
30200
30201   arg1 = (Dali::TouchData *)jarg1;
30202   arg2 = (std::size_t)jarg2;
30203   {
30204     try {
30205       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30206     } catch (std::out_of_range& e) {
30207       {
30208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30209       };
30210     } catch (std::exception& e) {
30211       {
30212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30213       };
30214     } catch (Dali::DaliException e) {
30215       {
30216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30217       };
30218     } catch (...) {
30219       {
30220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30221       };
30222     }
30223   }
30224
30225   jresult = result;
30226   return jresult;
30227 }
30228
30229
30230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30231   void * jresult ;
30232   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30233   std::size_t arg2 ;
30234   Dali::Degree result;
30235
30236   arg1 = (Dali::TouchData *)jarg1;
30237   arg2 = (std::size_t)jarg2;
30238   {
30239     try {
30240       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30241     } catch (std::out_of_range& e) {
30242       {
30243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30244       };
30245     } catch (std::exception& e) {
30246       {
30247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30248       };
30249     } catch (Dali::DaliException e) {
30250       {
30251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30252       };
30253     } catch (...) {
30254       {
30255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30256       };
30257     }
30258   }
30259
30260   jresult = new Dali::Degree((const Dali::Degree &)result);
30261   return jresult;
30262 }
30263
30264
30265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30266   int jresult ;
30267   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30268   std::size_t arg2 ;
30269   Dali::MouseButton::Type result;
30270
30271   arg1 = (Dali::TouchData *)jarg1;
30272   arg2 = (std::size_t)jarg2;
30273   {
30274     try {
30275       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30276     } catch (std::out_of_range& e) {
30277       {
30278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30279       };
30280     } catch (std::exception& e) {
30281       {
30282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30283       };
30284     } catch (Dali::DaliException e) {
30285       {
30286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30287       };
30288     } catch (...) {
30289       {
30290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30291       };
30292     }
30293   }
30294
30295   jresult = static_cast< int >(result);
30296   return jresult;
30297 }
30298
30299
30300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30301   void * jresult ;
30302   Dali::GestureDetector *result = 0 ;
30303
30304   {
30305     try {
30306       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30307     } catch (std::out_of_range& e) {
30308       {
30309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30310       };
30311     } catch (std::exception& e) {
30312       {
30313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30314       };
30315     } catch (Dali::DaliException e) {
30316       {
30317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30318       };
30319     } catch (...) {
30320       {
30321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30322       };
30323     }
30324   }
30325
30326   jresult = (void *)result;
30327   return jresult;
30328 }
30329
30330
30331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30332   void * jresult ;
30333   Dali::BaseHandle arg1 ;
30334   Dali::BaseHandle *argp1 ;
30335   Dali::GestureDetector result;
30336
30337   argp1 = (Dali::BaseHandle *)jarg1;
30338   if (!argp1) {
30339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30340     return 0;
30341   }
30342   arg1 = *argp1;
30343   {
30344     try {
30345       result = Dali::GestureDetector::DownCast(arg1);
30346     } catch (std::out_of_range& e) {
30347       {
30348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30349       };
30350     } catch (std::exception& e) {
30351       {
30352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30353       };
30354     } catch (Dali::DaliException e) {
30355       {
30356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30357       };
30358     } catch (...) {
30359       {
30360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30361       };
30362     }
30363   }
30364
30365   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30366   return jresult;
30367 }
30368
30369
30370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30371   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30372
30373   arg1 = (Dali::GestureDetector *)jarg1;
30374   {
30375     try {
30376       delete arg1;
30377     } catch (std::out_of_range& e) {
30378       {
30379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30380       };
30381     } catch (std::exception& e) {
30382       {
30383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30384       };
30385     } catch (Dali::DaliException e) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30388       };
30389     } catch (...) {
30390       {
30391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30392       };
30393     }
30394   }
30395
30396 }
30397
30398
30399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30400   void * jresult ;
30401   Dali::GestureDetector *arg1 = 0 ;
30402   Dali::GestureDetector *result = 0 ;
30403
30404   arg1 = (Dali::GestureDetector *)jarg1;
30405   if (!arg1) {
30406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30407     return 0;
30408   }
30409   {
30410     try {
30411       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30412     } catch (std::out_of_range& e) {
30413       {
30414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30415       };
30416     } catch (std::exception& e) {
30417       {
30418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30419       };
30420     } catch (Dali::DaliException e) {
30421       {
30422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30423       };
30424     } catch (...) {
30425       {
30426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30427       };
30428     }
30429   }
30430
30431   jresult = (void *)result;
30432   return jresult;
30433 }
30434
30435
30436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30437   void * jresult ;
30438   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30439   Dali::GestureDetector *arg2 = 0 ;
30440   Dali::GestureDetector *result = 0 ;
30441
30442   arg1 = (Dali::GestureDetector *)jarg1;
30443   arg2 = (Dali::GestureDetector *)jarg2;
30444   if (!arg2) {
30445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30446     return 0;
30447   }
30448   {
30449     try {
30450       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30451     } catch (std::out_of_range& e) {
30452       {
30453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30454       };
30455     } catch (std::exception& e) {
30456       {
30457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30458       };
30459     } catch (Dali::DaliException e) {
30460       {
30461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30462       };
30463     } catch (...) {
30464       {
30465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30466       };
30467     }
30468   }
30469
30470   jresult = (void *)result;
30471   return jresult;
30472 }
30473
30474
30475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30476   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30477   Dali::Actor arg2 ;
30478   Dali::Actor *argp2 ;
30479
30480   arg1 = (Dali::GestureDetector *)jarg1;
30481   argp2 = (Dali::Actor *)jarg2;
30482   if (!argp2) {
30483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30484     return ;
30485   }
30486   arg2 = *argp2;
30487   {
30488     try {
30489       (arg1)->Attach(arg2);
30490     } catch (std::out_of_range& e) {
30491       {
30492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30493       };
30494     } catch (std::exception& e) {
30495       {
30496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30497       };
30498     } catch (Dali::DaliException e) {
30499       {
30500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30501       };
30502     } catch (...) {
30503       {
30504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30505       };
30506     }
30507   }
30508
30509 }
30510
30511
30512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30513   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30514   Dali::Actor arg2 ;
30515   Dali::Actor *argp2 ;
30516
30517   arg1 = (Dali::GestureDetector *)jarg1;
30518   argp2 = (Dali::Actor *)jarg2;
30519   if (!argp2) {
30520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30521     return ;
30522   }
30523   arg2 = *argp2;
30524   {
30525     try {
30526       (arg1)->Detach(arg2);
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30534       };
30535     } catch (Dali::DaliException e) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30538       };
30539     } catch (...) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30542       };
30543     }
30544   }
30545
30546 }
30547
30548
30549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30550   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30551
30552   arg1 = (Dali::GestureDetector *)jarg1;
30553   {
30554     try {
30555       (arg1)->DetachAll();
30556     } catch (std::out_of_range& e) {
30557       {
30558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30559       };
30560     } catch (std::exception& e) {
30561       {
30562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30563       };
30564     } catch (Dali::DaliException e) {
30565       {
30566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30567       };
30568     } catch (...) {
30569       {
30570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30571       };
30572     }
30573   }
30574
30575 }
30576
30577
30578 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30579   unsigned long jresult ;
30580   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30581   size_t result;
30582
30583   arg1 = (Dali::GestureDetector *)jarg1;
30584   {
30585     try {
30586       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30587     } catch (std::out_of_range& e) {
30588       {
30589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30590       };
30591     } catch (std::exception& e) {
30592       {
30593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30594       };
30595     } catch (Dali::DaliException e) {
30596       {
30597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30598       };
30599     } catch (...) {
30600       {
30601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30602       };
30603     }
30604   }
30605
30606   jresult = (unsigned long)result;
30607   return jresult;
30608 }
30609
30610
30611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30612   void * jresult ;
30613   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30614   size_t arg2 ;
30615   Dali::Actor result;
30616
30617   arg1 = (Dali::GestureDetector *)jarg1;
30618   arg2 = (size_t)jarg2;
30619   {
30620     try {
30621       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30622     } catch (std::out_of_range& e) {
30623       {
30624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30625       };
30626     } catch (std::exception& e) {
30627       {
30628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30629       };
30630     } catch (Dali::DaliException e) {
30631       {
30632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30633       };
30634     } catch (...) {
30635       {
30636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30637       };
30638     }
30639   }
30640
30641   jresult = new Dali::Actor((const Dali::Actor &)result);
30642   return jresult;
30643 }
30644
30645
30646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30647   void * jresult ;
30648   Dali::Gesture *arg1 = 0 ;
30649   Dali::Gesture *result = 0 ;
30650
30651   arg1 = (Dali::Gesture *)jarg1;
30652   if (!arg1) {
30653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30654     return 0;
30655   }
30656   {
30657     try {
30658       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30659     } catch (std::out_of_range& e) {
30660       {
30661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30662       };
30663     } catch (std::exception& e) {
30664       {
30665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30666       };
30667     } catch (Dali::DaliException e) {
30668       {
30669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30670       };
30671     } catch (...) {
30672       {
30673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30674       };
30675     }
30676   }
30677
30678   jresult = (void *)result;
30679   return jresult;
30680 }
30681
30682
30683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30684   void * jresult ;
30685   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30686   Dali::Gesture *arg2 = 0 ;
30687   Dali::Gesture *result = 0 ;
30688
30689   arg1 = (Dali::Gesture *)jarg1;
30690   arg2 = (Dali::Gesture *)jarg2;
30691   if (!arg2) {
30692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30693     return 0;
30694   }
30695   {
30696     try {
30697       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30698     } catch (std::out_of_range& e) {
30699       {
30700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30701       };
30702     } catch (std::exception& e) {
30703       {
30704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30705       };
30706     } catch (Dali::DaliException e) {
30707       {
30708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30709       };
30710     } catch (...) {
30711       {
30712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30713       };
30714     }
30715   }
30716
30717   jresult = (void *)result;
30718   return jresult;
30719 }
30720
30721
30722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30723   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30724
30725   arg1 = (Dali::Gesture *)jarg1;
30726   {
30727     try {
30728       delete arg1;
30729     } catch (std::out_of_range& e) {
30730       {
30731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30732       };
30733     } catch (std::exception& e) {
30734       {
30735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30736       };
30737     } catch (Dali::DaliException e) {
30738       {
30739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30740       };
30741     } catch (...) {
30742       {
30743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30744       };
30745     }
30746   }
30747
30748 }
30749
30750
30751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30752   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30753   Dali::Gesture::Type arg2 ;
30754
30755   arg1 = (Dali::Gesture *)jarg1;
30756   arg2 = (Dali::Gesture::Type)jarg2;
30757   if (arg1) (arg1)->type = arg2;
30758 }
30759
30760
30761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30762   int jresult ;
30763   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30764   Dali::Gesture::Type result;
30765
30766   arg1 = (Dali::Gesture *)jarg1;
30767   result = (Dali::Gesture::Type) ((arg1)->type);
30768   jresult = (int)result;
30769   return jresult;
30770 }
30771
30772
30773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30774   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30775   Dali::Gesture::State arg2 ;
30776
30777   arg1 = (Dali::Gesture *)jarg1;
30778   arg2 = (Dali::Gesture::State)jarg2;
30779   if (arg1) (arg1)->state = arg2;
30780 }
30781
30782
30783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30784   int jresult ;
30785   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30786   Dali::Gesture::State result;
30787
30788   arg1 = (Dali::Gesture *)jarg1;
30789   result = (Dali::Gesture::State) ((arg1)->state);
30790   jresult = (int)result;
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30796   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30797   unsigned int arg2 ;
30798
30799   arg1 = (Dali::Gesture *)jarg1;
30800   arg2 = (unsigned int)jarg2;
30801   if (arg1) (arg1)->time = arg2;
30802 }
30803
30804
30805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30806   unsigned int jresult ;
30807   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30808   unsigned int result;
30809
30810   arg1 = (Dali::Gesture *)jarg1;
30811   result = (unsigned int) ((arg1)->time);
30812   jresult = result;
30813   return jresult;
30814 }
30815
30816
30817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30818   void * jresult ;
30819   Dali::HoverEvent *result = 0 ;
30820
30821   {
30822     try {
30823       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30824     } catch (std::out_of_range& e) {
30825       {
30826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30827       };
30828     } catch (std::exception& e) {
30829       {
30830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30831       };
30832     } catch (Dali::DaliException e) {
30833       {
30834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30835       };
30836     } catch (...) {
30837       {
30838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30839       };
30840     }
30841   }
30842
30843   jresult = (void *)result;
30844   return jresult;
30845 }
30846
30847
30848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30849   void * jresult ;
30850   unsigned long arg1 ;
30851   Dali::HoverEvent *result = 0 ;
30852
30853   arg1 = (unsigned long)jarg1;
30854   {
30855     try {
30856       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30857     } catch (std::out_of_range& e) {
30858       {
30859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30860       };
30861     } catch (std::exception& e) {
30862       {
30863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30864       };
30865     } catch (Dali::DaliException e) {
30866       {
30867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30868       };
30869     } catch (...) {
30870       {
30871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30872       };
30873     }
30874   }
30875
30876   jresult = (void *)result;
30877   return jresult;
30878 }
30879
30880
30881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30882   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30883
30884   arg1 = (Dali::HoverEvent *)jarg1;
30885   {
30886     try {
30887       delete arg1;
30888     } catch (std::out_of_range& e) {
30889       {
30890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30891       };
30892     } catch (std::exception& e) {
30893       {
30894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30895       };
30896     } catch (Dali::DaliException e) {
30897       {
30898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30899       };
30900     } catch (...) {
30901       {
30902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30903       };
30904     }
30905   }
30906
30907 }
30908
30909
30910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30911   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30912   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30913
30914   arg1 = (Dali::HoverEvent *)jarg1;
30915   arg2 = (Dali::TouchPointContainer *)jarg2;
30916   if (arg1) (arg1)->points = *arg2;
30917 }
30918
30919
30920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30921   void * jresult ;
30922   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30923   Dali::TouchPointContainer *result = 0 ;
30924
30925   arg1 = (Dali::HoverEvent *)jarg1;
30926   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30927   jresult = (void *)result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30933   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30934   unsigned long arg2 ;
30935
30936   arg1 = (Dali::HoverEvent *)jarg1;
30937   arg2 = (unsigned long)jarg2;
30938   if (arg1) (arg1)->time = arg2;
30939 }
30940
30941
30942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30943   unsigned long jresult ;
30944   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30945   unsigned long result;
30946
30947   arg1 = (Dali::HoverEvent *)jarg1;
30948   result = (unsigned long) ((arg1)->time);
30949   jresult = (unsigned long)result;
30950   return jresult;
30951 }
30952
30953
30954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30955   unsigned int jresult ;
30956   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30957   unsigned int result;
30958
30959   arg1 = (Dali::HoverEvent *)jarg1;
30960   {
30961     try {
30962       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30963     } catch (std::out_of_range& e) {
30964       {
30965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30966       };
30967     } catch (std::exception& e) {
30968       {
30969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (Dali::DaliException e) {
30972       {
30973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30974       };
30975     } catch (...) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30978       };
30979     }
30980   }
30981
30982   jresult = result;
30983   return jresult;
30984 }
30985
30986
30987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30988   void * jresult ;
30989   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30990   unsigned int arg2 ;
30991   Dali::TouchPoint *result = 0 ;
30992
30993   arg1 = (Dali::HoverEvent *)jarg1;
30994   arg2 = (unsigned int)jarg2;
30995   {
30996     try {
30997       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30998     } catch (std::out_of_range& e) {
30999       {
31000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31001       };
31002     } catch (std::exception& e) {
31003       {
31004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (Dali::DaliException e) {
31007       {
31008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31009       };
31010     } catch (...) {
31011       {
31012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31013       };
31014     }
31015   }
31016
31017   jresult = (void *)result;
31018   return jresult;
31019 }
31020
31021
31022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31023   void * jresult ;
31024   Dali::KeyEvent *result = 0 ;
31025
31026   {
31027     try {
31028       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (Dali::DaliException e) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31040       };
31041     } catch (...) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31044       };
31045     }
31046   }
31047
31048   jresult = (void *)result;
31049   return jresult;
31050 }
31051
31052
31053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31054   void * jresult ;
31055   std::string *arg1 = 0 ;
31056   std::string *arg2 = 0 ;
31057   int arg3 ;
31058   int arg4 ;
31059   unsigned long arg5 ;
31060   Dali::KeyEvent::State *arg6 = 0 ;
31061   Dali::KeyEvent::State temp6 ;
31062   Dali::KeyEvent *result = 0 ;
31063
31064   if (!jarg1) {
31065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31066     return 0;
31067   }
31068   std::string arg1_str(jarg1);
31069   arg1 = &arg1_str;
31070   if (!jarg2) {
31071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31072     return 0;
31073   }
31074   std::string arg2_str(jarg2);
31075   arg2 = &arg2_str;
31076   arg3 = (int)jarg3;
31077   arg4 = (int)jarg4;
31078   arg5 = (unsigned long)jarg5;
31079   temp6 = (Dali::KeyEvent::State)jarg6;
31080   arg6 = &temp6;
31081   {
31082     try {
31083       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31084     } catch (std::out_of_range& e) {
31085       {
31086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31087       };
31088     } catch (std::exception& e) {
31089       {
31090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31091       };
31092     } catch (Dali::DaliException e) {
31093       {
31094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31095       };
31096     } catch (...) {
31097       {
31098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31099       };
31100     }
31101   }
31102
31103   jresult = (void *)result;
31104
31105   //argout typemap for const std::string&
31106
31107
31108   //argout typemap for const std::string&
31109
31110   return jresult;
31111 }
31112
31113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31114   void * jresult ;
31115   Dali::KeyEvent *arg1 = 0 ;
31116   Dali::KeyEvent *result = 0 ;
31117
31118   arg1 = (Dali::KeyEvent *)jarg1;
31119   if (!arg1) {
31120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31121     return 0;
31122   }
31123   {
31124     try {
31125       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31126     } catch (std::out_of_range& e) {
31127       {
31128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31129       };
31130     } catch (std::exception& e) {
31131       {
31132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31133       };
31134     } catch (Dali::DaliException e) {
31135       {
31136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31137       };
31138     } catch (...) {
31139       {
31140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31141       };
31142     }
31143   }
31144
31145   jresult = (void *)result;
31146   return jresult;
31147 }
31148
31149
31150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31151   void * jresult ;
31152   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31153   Dali::KeyEvent *arg2 = 0 ;
31154   Dali::KeyEvent *result = 0 ;
31155
31156   arg1 = (Dali::KeyEvent *)jarg1;
31157   arg2 = (Dali::KeyEvent *)jarg2;
31158   if (!arg2) {
31159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31160     return 0;
31161   }
31162   {
31163     try {
31164       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31165     } catch (std::out_of_range& e) {
31166       {
31167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31168       };
31169     } catch (std::exception& e) {
31170       {
31171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31172       };
31173     } catch (Dali::DaliException e) {
31174       {
31175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31176       };
31177     } catch (...) {
31178       {
31179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31180       };
31181     }
31182   }
31183
31184   jresult = (void *)result;
31185   return jresult;
31186 }
31187
31188
31189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31190   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31191
31192   arg1 = (Dali::KeyEvent *)jarg1;
31193   {
31194     try {
31195       delete arg1;
31196     } catch (std::out_of_range& e) {
31197       {
31198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31199       };
31200     } catch (std::exception& e) {
31201       {
31202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31203       };
31204     } catch (Dali::DaliException e) {
31205       {
31206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31207       };
31208     } catch (...) {
31209       {
31210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31211       };
31212     }
31213   }
31214
31215 }
31216
31217
31218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31219   unsigned int jresult ;
31220   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31221   bool result;
31222
31223   arg1 = (Dali::KeyEvent *)jarg1;
31224   {
31225     try {
31226       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31227     } catch (std::out_of_range& e) {
31228       {
31229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31230       };
31231     } catch (std::exception& e) {
31232       {
31233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31234       };
31235     } catch (Dali::DaliException e) {
31236       {
31237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31238       };
31239     } catch (...) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31242       };
31243     }
31244   }
31245
31246   jresult = result;
31247   return jresult;
31248 }
31249
31250
31251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31252   unsigned int jresult ;
31253   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31254   bool result;
31255
31256   arg1 = (Dali::KeyEvent *)jarg1;
31257   {
31258     try {
31259       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31260     } catch (std::out_of_range& e) {
31261       {
31262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (std::exception& e) {
31265       {
31266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (Dali::DaliException e) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31271       };
31272     } catch (...) {
31273       {
31274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31275       };
31276     }
31277   }
31278
31279   jresult = result;
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31285   unsigned int jresult ;
31286   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31287   bool result;
31288
31289   arg1 = (Dali::KeyEvent *)jarg1;
31290   {
31291     try {
31292       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31293     } catch (std::out_of_range& e) {
31294       {
31295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31296       };
31297     } catch (std::exception& e) {
31298       {
31299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31300       };
31301     } catch (Dali::DaliException e) {
31302       {
31303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31304       };
31305     } catch (...) {
31306       {
31307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31308       };
31309     }
31310   }
31311
31312   jresult = result;
31313   return jresult;
31314 }
31315
31316
31317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31318   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31319   std::string *arg2 = 0 ;
31320
31321   arg1 = (Dali::KeyEvent *)jarg1;
31322   if (!jarg2) {
31323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31324     return ;
31325   }
31326   std::string arg2_str(jarg2);
31327   arg2 = &arg2_str;
31328   if (arg1) (arg1)->keyPressedName = *arg2;
31329
31330   //argout typemap for const std::string&
31331
31332 }
31333
31334
31335 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31336   char * jresult ;
31337
31338   if( jarg1 == NULL )
31339   {
31340     jresult = SWIG_csharp_string_callback( "" );
31341   }
31342   else
31343   {
31344     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31345     std::string *result = 0;
31346
31347     arg1 = ( Dali::KeyEvent * )jarg1;
31348     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31349     jresult = SWIG_csharp_string_callback( result->c_str() );
31350   }
31351
31352   return jresult;
31353 }
31354
31355
31356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31357   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31358   std::string *arg2 = 0 ;
31359
31360   arg1 = (Dali::KeyEvent *)jarg1;
31361   if (!jarg2) {
31362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31363     return ;
31364   }
31365   std::string arg2_str(jarg2);
31366   arg2 = &arg2_str;
31367   if (arg1) (arg1)->keyPressed = *arg2;
31368
31369   //argout typemap for const std::string&
31370
31371 }
31372
31373
31374 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31375   char * jresult ;
31376   if( NULL == jarg1 )
31377   {
31378     jresult = SWIG_csharp_string_callback( "" );
31379   }
31380   else
31381   {
31382     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31383     std::string *result = 0;
31384
31385     arg1 = ( Dali::KeyEvent * )jarg1;
31386     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31387     jresult = SWIG_csharp_string_callback( result->c_str() );
31388   }
31389   return jresult;
31390 }
31391
31392
31393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31394   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31395   int arg2 ;
31396
31397   arg1 = (Dali::KeyEvent *)jarg1;
31398   arg2 = (int)jarg2;
31399   if (arg1) (arg1)->keyCode = arg2;
31400 }
31401
31402
31403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31404   int jresult ;
31405   if( NULL == jarg1 )
31406   {
31407     jresult = -1;
31408   }
31409   else
31410   {
31411     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412     int result;
31413
31414     arg1 = ( Dali::KeyEvent * )jarg1;
31415     result = (int)( ( arg1 )->keyCode );
31416     jresult = result;
31417   }
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31423   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31424   int arg2 ;
31425
31426   arg1 = (Dali::KeyEvent *)jarg1;
31427   arg2 = (int)jarg2;
31428   if (arg1) (arg1)->keyModifier = arg2;
31429 }
31430
31431
31432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31433   int jresult ;
31434   if( jarg1 == NULL )
31435   {
31436     jresult = -1;
31437   }
31438   else
31439   {
31440     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31441     int result;
31442
31443     arg1 = ( Dali::KeyEvent * )jarg1;
31444     result = (int)( ( arg1 )->keyModifier );
31445     jresult = result;
31446   }
31447   return jresult;
31448 }
31449
31450
31451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31453   unsigned long arg2 ;
31454
31455   arg1 = (Dali::KeyEvent *)jarg1;
31456   arg2 = (unsigned long)jarg2;
31457   if (arg1) (arg1)->time = arg2;
31458 }
31459
31460
31461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31462   unsigned long jresult ;
31463   if( jarg1 == NULL )
31464   {
31465     jresult = 0;
31466   }
31467   else
31468   {
31469     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31470     unsigned long result;
31471
31472     arg1 = ( Dali::KeyEvent * )jarg1;
31473     result = (unsigned long)( ( arg1 )->time );
31474     jresult = (unsigned long)result;
31475   }
31476   return jresult;
31477 }
31478
31479
31480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31481   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31482   Dali::KeyEvent::State arg2 ;
31483
31484   arg1 = (Dali::KeyEvent *)jarg1;
31485   arg2 = (Dali::KeyEvent::State)jarg2;
31486   if (arg1) (arg1)->state = arg2;
31487 }
31488
31489
31490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31491   int jresult ;
31492   if( jarg1 == NULL )
31493   {
31494     jresult = -1;
31495   }
31496   else
31497   {
31498     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31499     Dali::KeyEvent::State result;
31500
31501     arg1 = ( Dali::KeyEvent * )jarg1;
31502     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31503     jresult = (int)result;
31504   }
31505   return jresult;
31506 }
31507
31508 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31509   char * jresult ;
31510   std::string result;
31511   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31512
31513   arg1 = (Dali::KeyEvent *)jarg1;
31514   if (!arg1) {
31515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31516     return 0;
31517   }
31518   {
31519     try {
31520       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31521     } catch (std::out_of_range& e) {
31522       {
31523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31524       };
31525     } catch (std::exception& e) {
31526       {
31527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31528       };
31529     } catch (Dali::DaliException e) {
31530       {
31531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31532       };
31533     } catch (...) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31536       };
31537     }
31538
31539   }
31540
31541   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31542   return jresult;
31543 }
31544
31545
31546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31547   void * jresult ;
31548   Dali::LongPressGestureDetector *result = 0 ;
31549
31550   {
31551     try {
31552       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31553     } catch (std::out_of_range& e) {
31554       {
31555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31556       };
31557     } catch (std::exception& e) {
31558       {
31559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (Dali::DaliException e) {
31562       {
31563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571
31572   jresult = (void *)result;
31573   return jresult;
31574 }
31575
31576
31577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31578   void * jresult ;
31579   Dali::LongPressGestureDetector result;
31580
31581   {
31582     try {
31583       result = Dali::LongPressGestureDetector::New();
31584     } catch (std::out_of_range& e) {
31585       {
31586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31587       };
31588     } catch (std::exception& e) {
31589       {
31590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31591       };
31592     } catch (Dali::DaliException e) {
31593       {
31594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31595       };
31596     } catch (...) {
31597       {
31598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31599       };
31600     }
31601   }
31602
31603   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31604   return jresult;
31605 }
31606
31607
31608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31609   void * jresult ;
31610   unsigned int arg1 ;
31611   Dali::LongPressGestureDetector result;
31612
31613   arg1 = (unsigned int)jarg1;
31614   {
31615     try {
31616       result = Dali::LongPressGestureDetector::New(arg1);
31617     } catch (std::out_of_range& e) {
31618       {
31619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31620       };
31621     } catch (std::exception& e) {
31622       {
31623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31624       };
31625     } catch (Dali::DaliException e) {
31626       {
31627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31628       };
31629     } catch (...) {
31630       {
31631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31632       };
31633     }
31634   }
31635
31636   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31637   return jresult;
31638 }
31639
31640
31641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31642   void * jresult ;
31643   unsigned int arg1 ;
31644   unsigned int arg2 ;
31645   Dali::LongPressGestureDetector result;
31646
31647   arg1 = (unsigned int)jarg1;
31648   arg2 = (unsigned int)jarg2;
31649   {
31650     try {
31651       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31652     } catch (std::out_of_range& e) {
31653       {
31654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31655       };
31656     } catch (std::exception& e) {
31657       {
31658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (Dali::DaliException e) {
31661       {
31662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31663       };
31664     } catch (...) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31667       };
31668     }
31669   }
31670
31671   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31672   return jresult;
31673 }
31674
31675
31676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31677   void * jresult ;
31678   Dali::BaseHandle arg1 ;
31679   Dali::BaseHandle *argp1 ;
31680   Dali::LongPressGestureDetector result;
31681
31682   argp1 = (Dali::BaseHandle *)jarg1;
31683   if (!argp1) {
31684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31685     return 0;
31686   }
31687   arg1 = *argp1;
31688   {
31689     try {
31690       result = Dali::LongPressGestureDetector::DownCast(arg1);
31691     } catch (std::out_of_range& e) {
31692       {
31693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31694       };
31695     } catch (std::exception& e) {
31696       {
31697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (Dali::DaliException e) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709
31710   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31711   return jresult;
31712 }
31713
31714
31715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31716   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31717
31718   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31719   {
31720     try {
31721       delete arg1;
31722     } catch (std::out_of_range& e) {
31723       {
31724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31725       };
31726     } catch (std::exception& e) {
31727       {
31728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31729       };
31730     } catch (Dali::DaliException e) {
31731       {
31732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31733       };
31734     } catch (...) {
31735       {
31736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31737       };
31738     }
31739   }
31740
31741 }
31742
31743
31744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31745   void * jresult ;
31746   Dali::LongPressGestureDetector *arg1 = 0 ;
31747   Dali::LongPressGestureDetector *result = 0 ;
31748
31749   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31750   if (!arg1) {
31751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31752     return 0;
31753   }
31754   {
31755     try {
31756       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31757     } catch (std::out_of_range& e) {
31758       {
31759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31760       };
31761     } catch (std::exception& e) {
31762       {
31763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31764       };
31765     } catch (Dali::DaliException e) {
31766       {
31767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31768       };
31769     } catch (...) {
31770       {
31771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31772       };
31773     }
31774   }
31775
31776   jresult = (void *)result;
31777   return jresult;
31778 }
31779
31780
31781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31782   void * jresult ;
31783   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31784   Dali::LongPressGestureDetector *arg2 = 0 ;
31785   Dali::LongPressGestureDetector *result = 0 ;
31786
31787   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31788   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31789   if (!arg2) {
31790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31791     return 0;
31792   }
31793   {
31794     try {
31795       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31796     } catch (std::out_of_range& e) {
31797       {
31798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31799       };
31800     } catch (std::exception& e) {
31801       {
31802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31803       };
31804     } catch (Dali::DaliException e) {
31805       {
31806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31807       };
31808     } catch (...) {
31809       {
31810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31811       };
31812     }
31813   }
31814
31815   jresult = (void *)result;
31816   return jresult;
31817 }
31818
31819
31820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31821   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31822   unsigned int arg2 ;
31823
31824   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31825   arg2 = (unsigned int)jarg2;
31826   {
31827     try {
31828       (arg1)->SetTouchesRequired(arg2);
31829     } catch (std::out_of_range& e) {
31830       {
31831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31832       };
31833     } catch (std::exception& e) {
31834       {
31835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31836       };
31837     } catch (Dali::DaliException e) {
31838       {
31839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31840       };
31841     } catch (...) {
31842       {
31843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31844       };
31845     }
31846   }
31847
31848 }
31849
31850
31851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31852   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31853   unsigned int arg2 ;
31854   unsigned int arg3 ;
31855
31856   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31857   arg2 = (unsigned int)jarg2;
31858   arg3 = (unsigned int)jarg3;
31859   {
31860     try {
31861       (arg1)->SetTouchesRequired(arg2,arg3);
31862     } catch (std::out_of_range& e) {
31863       {
31864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31865       };
31866     } catch (std::exception& e) {
31867       {
31868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31869       };
31870     } catch (Dali::DaliException e) {
31871       {
31872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31873       };
31874     } catch (...) {
31875       {
31876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31877       };
31878     }
31879   }
31880
31881 }
31882
31883
31884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31885   unsigned int jresult ;
31886   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31887   unsigned int result;
31888
31889   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31890   {
31891     try {
31892       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31893     } catch (std::out_of_range& e) {
31894       {
31895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31896       };
31897     } catch (std::exception& e) {
31898       {
31899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (Dali::DaliException e) {
31902       {
31903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31904       };
31905     } catch (...) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31908       };
31909     }
31910   }
31911
31912   jresult = result;
31913   return jresult;
31914 }
31915
31916
31917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31918   unsigned int jresult ;
31919   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31920   unsigned int result;
31921
31922   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31923   {
31924     try {
31925       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31926     } catch (std::out_of_range& e) {
31927       {
31928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31929       };
31930     } catch (std::exception& e) {
31931       {
31932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31933       };
31934     } catch (Dali::DaliException e) {
31935       {
31936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31937       };
31938     } catch (...) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31941       };
31942     }
31943   }
31944
31945   jresult = result;
31946   return jresult;
31947 }
31948
31949
31950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31951   void * jresult ;
31952   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31953   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31954
31955   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31956   {
31957     try {
31958       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31959     } catch (std::out_of_range& e) {
31960       {
31961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (std::exception& e) {
31964       {
31965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31966       };
31967     } catch (Dali::DaliException e) {
31968       {
31969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31970       };
31971     } catch (...) {
31972       {
31973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31974       };
31975     }
31976   }
31977
31978   jresult = (void *)result;
31979   return jresult;
31980 }
31981
31982
31983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31984   void * jresult ;
31985   Dali::Gesture::State arg1 ;
31986   Dali::LongPressGesture *result = 0 ;
31987
31988   arg1 = (Dali::Gesture::State)jarg1;
31989   {
31990     try {
31991       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31992     } catch (std::out_of_range& e) {
31993       {
31994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31995       };
31996     } catch (std::exception& e) {
31997       {
31998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31999       };
32000     } catch (Dali::DaliException e) {
32001       {
32002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32003       };
32004     } catch (...) {
32005       {
32006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32007       };
32008     }
32009   }
32010
32011   jresult = (void *)result;
32012   return jresult;
32013 }
32014
32015
32016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32017   void * jresult ;
32018   Dali::LongPressGesture *arg1 = 0 ;
32019   Dali::LongPressGesture *result = 0 ;
32020
32021   arg1 = (Dali::LongPressGesture *)jarg1;
32022   if (!arg1) {
32023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32024     return 0;
32025   }
32026   {
32027     try {
32028       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32029     } catch (std::out_of_range& e) {
32030       {
32031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32032       };
32033     } catch (std::exception& e) {
32034       {
32035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32036       };
32037     } catch (Dali::DaliException e) {
32038       {
32039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32040       };
32041     } catch (...) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32044       };
32045     }
32046   }
32047
32048   jresult = (void *)result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32054   void * jresult ;
32055   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32056   Dali::LongPressGesture *arg2 = 0 ;
32057   Dali::LongPressGesture *result = 0 ;
32058
32059   arg1 = (Dali::LongPressGesture *)jarg1;
32060   arg2 = (Dali::LongPressGesture *)jarg2;
32061   if (!arg2) {
32062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32063     return 0;
32064   }
32065   {
32066     try {
32067       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32068     } catch (std::out_of_range& e) {
32069       {
32070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32071       };
32072     } catch (std::exception& e) {
32073       {
32074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32075       };
32076     } catch (Dali::DaliException e) {
32077       {
32078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32079       };
32080     } catch (...) {
32081       {
32082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32083       };
32084     }
32085   }
32086
32087   jresult = (void *)result;
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32093   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32094
32095   arg1 = (Dali::LongPressGesture *)jarg1;
32096   {
32097     try {
32098       delete arg1;
32099     } catch (std::out_of_range& e) {
32100       {
32101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32102       };
32103     } catch (std::exception& e) {
32104       {
32105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32106       };
32107     } catch (Dali::DaliException e) {
32108       {
32109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32110       };
32111     } catch (...) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32114       };
32115     }
32116   }
32117
32118 }
32119
32120
32121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32122   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32123   unsigned int arg2 ;
32124
32125   arg1 = (Dali::LongPressGesture *)jarg1;
32126   arg2 = (unsigned int)jarg2;
32127   if (arg1) (arg1)->numberOfTouches = arg2;
32128 }
32129
32130
32131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32132   unsigned int jresult ;
32133   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32134   unsigned int result;
32135
32136   arg1 = (Dali::LongPressGesture *)jarg1;
32137   result = (unsigned int) ((arg1)->numberOfTouches);
32138   jresult = result;
32139   return jresult;
32140 }
32141
32142
32143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32144   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32145   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32146
32147   arg1 = (Dali::LongPressGesture *)jarg1;
32148   arg2 = (Dali::Vector2 *)jarg2;
32149   if (arg1) (arg1)->screenPoint = *arg2;
32150 }
32151
32152
32153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32154   void * jresult ;
32155   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32156   Dali::Vector2 *result = 0 ;
32157
32158   arg1 = (Dali::LongPressGesture *)jarg1;
32159   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32160   jresult = (void *)result;
32161   return jresult;
32162 }
32163
32164
32165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32166   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32167   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32168
32169   arg1 = (Dali::LongPressGesture *)jarg1;
32170   arg2 = (Dali::Vector2 *)jarg2;
32171   if (arg1) (arg1)->localPoint = *arg2;
32172 }
32173
32174
32175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32176   void * jresult ;
32177   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32178   Dali::Vector2 *result = 0 ;
32179
32180   arg1 = (Dali::LongPressGesture *)jarg1;
32181   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32182   jresult = (void *)result;
32183   return jresult;
32184 }
32185
32186
32187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32188   void * jresult ;
32189   Dali::WheelEvent *result = 0 ;
32190
32191   {
32192     try {
32193       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32194     } catch (std::out_of_range& e) {
32195       {
32196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32197       };
32198     } catch (std::exception& e) {
32199       {
32200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32201       };
32202     } catch (Dali::DaliException e) {
32203       {
32204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32205       };
32206     } catch (...) {
32207       {
32208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32209       };
32210     }
32211   }
32212
32213   jresult = (void *)result;
32214   return jresult;
32215 }
32216
32217
32218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32219   void * jresult ;
32220   Dali::WheelEvent::Type arg1 ;
32221   int arg2 ;
32222   unsigned int arg3 ;
32223   Dali::Vector2 arg4 ;
32224   int arg5 ;
32225   unsigned int arg6 ;
32226   Dali::Vector2 *argp4 ;
32227   Dali::WheelEvent *result = 0 ;
32228
32229   arg1 = (Dali::WheelEvent::Type)jarg1;
32230   arg2 = (int)jarg2;
32231   arg3 = (unsigned int)jarg3;
32232   argp4 = (Dali::Vector2 *)jarg4;
32233   if (!argp4) {
32234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32235     return 0;
32236   }
32237   arg4 = *argp4;
32238   arg5 = (int)jarg5;
32239   arg6 = (unsigned int)jarg6;
32240   {
32241     try {
32242       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32243     } catch (std::out_of_range& e) {
32244       {
32245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32246       };
32247     } catch (std::exception& e) {
32248       {
32249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (Dali::DaliException e) {
32252       {
32253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32254       };
32255     } catch (...) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32258       };
32259     }
32260   }
32261
32262   jresult = (void *)result;
32263   return jresult;
32264 }
32265
32266
32267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32268   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32269
32270   arg1 = (Dali::WheelEvent *)jarg1;
32271   {
32272     try {
32273       delete arg1;
32274     } catch (std::out_of_range& e) {
32275       {
32276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32277       };
32278     } catch (std::exception& e) {
32279       {
32280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32281       };
32282     } catch (Dali::DaliException e) {
32283       {
32284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32285       };
32286     } catch (...) {
32287       {
32288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32289       };
32290     }
32291   }
32292
32293 }
32294
32295
32296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32297   unsigned int jresult ;
32298   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32299   bool result;
32300
32301   arg1 = (Dali::WheelEvent *)jarg1;
32302   {
32303     try {
32304       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32305     } catch (std::out_of_range& e) {
32306       {
32307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32308       };
32309     } catch (std::exception& e) {
32310       {
32311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32312       };
32313     } catch (Dali::DaliException e) {
32314       {
32315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32320       };
32321     }
32322   }
32323
32324   jresult = result;
32325   return jresult;
32326 }
32327
32328
32329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32330   unsigned int jresult ;
32331   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32332   bool result;
32333
32334   arg1 = (Dali::WheelEvent *)jarg1;
32335   {
32336     try {
32337       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32338     } catch (std::out_of_range& e) {
32339       {
32340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32341       };
32342     } catch (std::exception& e) {
32343       {
32344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32345       };
32346     } catch (Dali::DaliException e) {
32347       {
32348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32349       };
32350     } catch (...) {
32351       {
32352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32353       };
32354     }
32355   }
32356
32357   jresult = result;
32358   return jresult;
32359 }
32360
32361
32362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32363   unsigned int jresult ;
32364   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32365   bool result;
32366
32367   arg1 = (Dali::WheelEvent *)jarg1;
32368   {
32369     try {
32370       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32371     } catch (std::out_of_range& e) {
32372       {
32373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32374       };
32375     } catch (std::exception& e) {
32376       {
32377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32378       };
32379     } catch (Dali::DaliException e) {
32380       {
32381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32382       };
32383     } catch (...) {
32384       {
32385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32386       };
32387     }
32388   }
32389
32390   jresult = result;
32391   return jresult;
32392 }
32393
32394
32395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32396   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32397   Dali::WheelEvent::Type arg2 ;
32398
32399   arg1 = (Dali::WheelEvent *)jarg1;
32400   arg2 = (Dali::WheelEvent::Type)jarg2;
32401   if (arg1) (arg1)->type = arg2;
32402 }
32403
32404
32405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32406   int jresult ;
32407   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32408   Dali::WheelEvent::Type result;
32409
32410   arg1 = (Dali::WheelEvent *)jarg1;
32411   result = (Dali::WheelEvent::Type) ((arg1)->type);
32412   jresult = (int)result;
32413   return jresult;
32414 }
32415
32416
32417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32418   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32419   int arg2 ;
32420
32421   arg1 = (Dali::WheelEvent *)jarg1;
32422   arg2 = (int)jarg2;
32423   if (arg1) (arg1)->direction = arg2;
32424 }
32425
32426
32427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32428   int jresult ;
32429   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32430   int result;
32431
32432   arg1 = (Dali::WheelEvent *)jarg1;
32433   result = (int) ((arg1)->direction);
32434   jresult = result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32440   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32441   unsigned int arg2 ;
32442
32443   arg1 = (Dali::WheelEvent *)jarg1;
32444   arg2 = (unsigned int)jarg2;
32445   if (arg1) (arg1)->modifiers = arg2;
32446 }
32447
32448
32449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32450   unsigned int jresult ;
32451   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32452   unsigned int result;
32453
32454   arg1 = (Dali::WheelEvent *)jarg1;
32455   result = (unsigned int) ((arg1)->modifiers);
32456   jresult = result;
32457   return jresult;
32458 }
32459
32460
32461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32462   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32463   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32464
32465   arg1 = (Dali::WheelEvent *)jarg1;
32466   arg2 = (Dali::Vector2 *)jarg2;
32467   if (arg1) (arg1)->point = *arg2;
32468 }
32469
32470
32471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32472   void * jresult ;
32473   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32474   Dali::Vector2 *result = 0 ;
32475
32476   arg1 = (Dali::WheelEvent *)jarg1;
32477   result = (Dali::Vector2 *)& ((arg1)->point);
32478   jresult = (void *)result;
32479   return jresult;
32480 }
32481
32482
32483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32484   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32485   int arg2 ;
32486
32487   arg1 = (Dali::WheelEvent *)jarg1;
32488   arg2 = (int)jarg2;
32489   if (arg1) (arg1)->z = arg2;
32490 }
32491
32492
32493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32494   int jresult ;
32495   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32496   int result;
32497
32498   arg1 = (Dali::WheelEvent *)jarg1;
32499   result = (int) ((arg1)->z);
32500   jresult = result;
32501   return jresult;
32502 }
32503
32504
32505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32506   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32507   unsigned int arg2 ;
32508
32509   arg1 = (Dali::WheelEvent *)jarg1;
32510   arg2 = (unsigned int)jarg2;
32511   if (arg1) (arg1)->timeStamp = arg2;
32512 }
32513
32514
32515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32516   unsigned int jresult ;
32517   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32518   unsigned int result;
32519
32520   arg1 = (Dali::WheelEvent *)jarg1;
32521   result = (unsigned int) ((arg1)->timeStamp);
32522   jresult = result;
32523   return jresult;
32524 }
32525
32526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32527   char * jresult ;
32528   Dali::KeyEvent *arg1 = 0 ;
32529   std::string result;
32530
32531   arg1 = (Dali::KeyEvent *)jarg1;
32532   if (!arg1) {
32533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32534     return 0;
32535   }
32536   {
32537     try {
32538       result = arg1->GetDeviceName();
32539     } catch (std::out_of_range& e) {
32540       {
32541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32542       };
32543     } catch (std::exception& e) {
32544       {
32545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32546       };
32547     } catch (Dali::DaliException e) {
32548       {
32549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32550       };
32551     } catch (...) {
32552       {
32553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32554       };
32555     }
32556   }
32557
32558   jresult = SWIG_csharp_string_callback((&result)->c_str());
32559   return jresult;
32560 }
32561
32562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32563   int jresult ;
32564   Dali::KeyEvent *arg1 = 0 ;
32565   Dali::Device::Class::Type result;
32566
32567   arg1 = (Dali::KeyEvent *)jarg1;
32568   if (!arg1) {
32569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32570     return 0;
32571   }
32572   {
32573     try {
32574       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32575     } catch (std::out_of_range& e) {
32576       {
32577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32578       };
32579     } catch (std::exception& e) {
32580       {
32581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32582       };
32583     } catch (Dali::DaliException e) {
32584       {
32585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32586       };
32587     } catch (...) {
32588       {
32589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32590       };
32591     }
32592   }
32593
32594   jresult = (int)result;
32595   return jresult;
32596 }
32597
32598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32599   int jresult ;
32600   Dali::KeyEvent *arg1 = 0 ;
32601   Dali::Device::Subclass::Type result;
32602
32603   arg1 = (Dali::KeyEvent *)jarg1;
32604   if (!arg1) {
32605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32606     return 0;
32607   }
32608   {
32609     try {
32610       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32611     } catch (std::out_of_range& e) {
32612       {
32613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32614       };
32615     } catch (std::exception& e) {
32616       {
32617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32618       };
32619     } catch (Dali::DaliException e) {
32620       {
32621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32622       };
32623     } catch (...) {
32624       {
32625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32626       };
32627     }
32628   }
32629
32630   jresult = (int)result;
32631   return jresult;
32632 }
32633
32634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32635   Dali::Actor arg1 ;
32636   Dali::Actor *argp1 ;
32637
32638   argp1 = (Dali::Actor *)jarg1;
32639   if (!argp1) {
32640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32641     return ;
32642   }
32643   arg1 = *argp1;
32644   {
32645     try {
32646       arg1.Raise();
32647     } catch (std::out_of_range& e) {
32648       {
32649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32650       };
32651     } catch (std::exception& e) {
32652       {
32653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32654       };
32655     } catch (Dali::DaliException e) {
32656       {
32657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32658       };
32659     } catch (...) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32662       };
32663     }
32664   }
32665
32666 }
32667
32668
32669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32670   Dali::Actor arg1 ;
32671   Dali::Actor *argp1 ;
32672
32673   argp1 = (Dali::Actor *)jarg1;
32674   if (!argp1) {
32675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32676     return ;
32677   }
32678   arg1 = *argp1;
32679   {
32680     try {
32681       arg1.Lower();
32682     } catch (std::out_of_range& e) {
32683       {
32684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32685       };
32686     } catch (std::exception& e) {
32687       {
32688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (Dali::DaliException e) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32693       };
32694     } catch (...) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32697       };
32698     }
32699   }
32700
32701 }
32702
32703
32704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32705   Dali::Actor arg1 ;
32706   Dali::Actor *argp1 ;
32707
32708   argp1 = (Dali::Actor *)jarg1;
32709   if (!argp1) {
32710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32711     return ;
32712   }
32713   arg1 = *argp1;
32714   {
32715     try {
32716       arg1.RaiseToTop();
32717     } catch (std::out_of_range& e) {
32718       {
32719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32720       };
32721     } catch (std::exception& e) {
32722       {
32723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32724       };
32725     } catch (Dali::DaliException e) {
32726       {
32727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32728       };
32729     } catch (...) {
32730       {
32731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32732       };
32733     }
32734   }
32735
32736 }
32737
32738
32739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32740   Dali::Actor arg1 ;
32741   Dali::Actor *argp1 ;
32742
32743   argp1 = (Dali::Actor *)jarg1;
32744   if (!argp1) {
32745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32746     return ;
32747   }
32748   arg1 = *argp1;
32749   {
32750     try {
32751       arg1.LowerToBottom();
32752     } catch (std::out_of_range& e) {
32753       {
32754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32755       };
32756     } catch (std::exception& e) {
32757       {
32758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32759       };
32760     } catch (Dali::DaliException e) {
32761       {
32762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32763       };
32764     } catch (...) {
32765       {
32766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32767       };
32768     }
32769   }
32770
32771 }
32772
32773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32774   Dali::Actor arg1 ;
32775   Dali::Actor arg2 ;
32776   Dali::Actor *argp1 ;
32777   Dali::Actor *argp2 ;
32778
32779   argp1 = (Dali::Actor *)jarg1;
32780   if (!argp1) {
32781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32782     return ;
32783   }
32784   arg1 = *argp1;
32785   argp2 = (Dali::Actor *)jarg2;
32786   if (!argp2) {
32787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32788     return ;
32789   }
32790   arg2 = *argp2;
32791   {
32792     try {
32793       arg1.RaiseAbove(arg2);
32794     } catch (std::out_of_range& e) {
32795       {
32796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32797       };
32798     } catch (std::exception& e) {
32799       {
32800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32801       };
32802     } catch (Dali::DaliException e) {
32803       {
32804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32805       };
32806     } catch (...) {
32807       {
32808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32809       };
32810     }
32811   }
32812
32813 }
32814
32815
32816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32817   Dali::Actor arg1 ;
32818   Dali::Actor arg2 ;
32819   Dali::Actor *argp1 ;
32820   Dali::Actor *argp2 ;
32821
32822   argp1 = (Dali::Actor *)jarg1;
32823   if (!argp1) {
32824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32825     return ;
32826   }
32827   arg1 = *argp1;
32828   argp2 = (Dali::Actor *)jarg2;
32829   if (!argp2) {
32830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32831     return ;
32832   }
32833   arg2 = *argp2;
32834   {
32835     try {
32836       arg1.LowerBelow(arg2);
32837     } catch (std::out_of_range& e) {
32838       {
32839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32840       };
32841     } catch (std::exception& e) {
32842       {
32843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32844       };
32845     } catch (Dali::DaliException e) {
32846       {
32847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32848       };
32849     } catch (...) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32852       };
32853     }
32854   }
32855
32856 }
32857
32858
32859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32860   void * jresult ;
32861   Dali::Actor arg1 ;
32862   Dali::Actor *argp1 ;
32863   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32864
32865   argp1 = (Dali::Actor *)jarg1;
32866   if (!argp1) {
32867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32868     return 0;
32869   }
32870   arg1 = *argp1;
32871   {
32872     try {
32873       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32874     } catch (std::out_of_range& e) {
32875       {
32876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32877       };
32878     } catch (std::exception& e) {
32879       {
32880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32881       };
32882     } catch (Dali::DaliException e) {
32883       {
32884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32885       };
32886     } catch (...) {
32887       {
32888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32889       };
32890     }
32891   }
32892
32893   jresult = (void *)result;
32894   return jresult;
32895 }
32896
32897
32898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32899   void * jresult ;
32900   Dali::Actor *arg1 ;
32901   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32902
32903   arg1 = (Dali::Actor *)jarg1;
32904   {
32905     try {
32906       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32907     } catch (std::out_of_range& e) {
32908       {
32909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32910       };
32911     } catch (std::exception& e) {
32912       {
32913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32914       };
32915     } catch (Dali::DaliException e) {
32916       {
32917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32918       };
32919     } catch (...) {
32920       {
32921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32922       };
32923     }
32924   }
32925
32926   jresult = (void *)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::SIZE;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::POSITION;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::POSITION_X;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::POSITION_Y;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::POSITION_Z;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::WORLD_POSITION;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::ORIENTATION;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::SCALE;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::SCALE_X;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::SCALE_Y;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::SCALE_Z;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::WORLD_SCALE;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::VISIBLE;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::COLOR;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::COLOR_RED;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::COLOR_GREEN;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33242   int jresult ;
33243   int result;
33244
33245   result = (int)Dali::Actor::Property::COLOR_BLUE;
33246   jresult = (int)result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33252   int jresult ;
33253   int result;
33254
33255   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33256   jresult = (int)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33262   int jresult ;
33263   int result;
33264
33265   result = (int)Dali::Actor::Property::WORLD_COLOR;
33266   jresult = (int)result;
33267   return jresult;
33268 }
33269
33270
33271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33272   int jresult ;
33273   int result;
33274
33275   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33276   jresult = (int)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33282   int jresult ;
33283   int result;
33284
33285   result = (int)Dali::Actor::Property::NAME;
33286   jresult = (int)result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33292   int jresult ;
33293   int result;
33294
33295   result = (int)Dali::Actor::Property::SENSITIVE;
33296   jresult = (int)result;
33297   return jresult;
33298 }
33299
33300
33301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33302   int jresult ;
33303   int result;
33304
33305   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33306   jresult = (int)result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33312   int jresult ;
33313   int result;
33314
33315   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33316   jresult = (int)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33322   int jresult ;
33323   int result;
33324
33325   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33326   jresult = (int)result;
33327   return jresult;
33328 }
33329
33330
33331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33332   int jresult ;
33333   int result;
33334
33335   result = (int)Dali::Actor::Property::COLOR_MODE;
33336   jresult = (int)result;
33337   return jresult;
33338 }
33339
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33342   int jresult ;
33343   int result;
33344
33345   result = (int)Dali::Actor::Property::DRAW_MODE;
33346   jresult = (int)result;
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33352   int jresult ;
33353   int result;
33354
33355   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33356   jresult = (int)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33362   int jresult ;
33363   int result;
33364
33365   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33366   jresult = (int)result;
33367   return jresult;
33368 }
33369
33370
33371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33372   int jresult ;
33373   int result;
33374
33375   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33376   jresult = (int)result;
33377   return jresult;
33378 }
33379
33380
33381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33382   int jresult ;
33383   int result;
33384
33385   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33386   jresult = (int)result;
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33392   int jresult ;
33393   int result;
33394
33395   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33396   jresult = (int)result;
33397   return jresult;
33398 }
33399
33400
33401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33402   int jresult ;
33403   int result;
33404
33405   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33406   jresult = (int)result;
33407   return jresult;
33408 }
33409
33410
33411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33412   int jresult ;
33413   int result;
33414
33415   result = (int)Dali::Actor::Property::PADDING;
33416   jresult = (int)result;
33417   return jresult;
33418 }
33419
33420
33421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33422   int jresult ;
33423   int result;
33424
33425   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33426   jresult = (int)result;
33427   return jresult;
33428 }
33429
33430
33431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33432   int jresult ;
33433   int result;
33434
33435   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33436   jresult = (int)result;
33437   return jresult;
33438 }
33439
33440
33441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33442   int jresult ;
33443   int result;
33444
33445   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33446   jresult = (int)result;
33447   return jresult;
33448 }
33449
33450
33451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33452   int jresult ;
33453   int result;
33454
33455   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33456   jresult = (int)result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33462   void * jresult ;
33463   Dali::Actor::Property *result = 0 ;
33464
33465   {
33466     try {
33467       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33468     } catch (std::out_of_range& e) {
33469       {
33470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33471       };
33472     } catch (std::exception& e) {
33473       {
33474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (Dali::DaliException e) {
33477       {
33478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33479       };
33480     } catch (...) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33483       };
33484     }
33485   }
33486
33487   jresult = (void *)result;
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33493   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33494
33495   arg1 = (Dali::Actor::Property *)jarg1;
33496   {
33497     try {
33498       delete arg1;
33499     } catch (std::out_of_range& e) {
33500       {
33501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33502       };
33503     } catch (std::exception& e) {
33504       {
33505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33506       };
33507     } catch (Dali::DaliException e) {
33508       {
33509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33510       };
33511     } catch (...) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33514       };
33515     }
33516   }
33517
33518 }
33519
33520
33521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33522   void * jresult ;
33523   Dali::Actor *result = 0 ;
33524
33525   {
33526     try {
33527       result = (Dali::Actor *)new Dali::Actor();
33528     } catch (std::out_of_range& e) {
33529       {
33530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33531       };
33532     } catch (std::exception& e) {
33533       {
33534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33535       };
33536     } catch (Dali::DaliException e) {
33537       {
33538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33539       };
33540     } catch (...) {
33541       {
33542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33543       };
33544     }
33545   }
33546
33547   jresult = (void *)result;
33548   return jresult;
33549 }
33550
33551
33552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33553   void * jresult ;
33554   Dali::Actor result;
33555
33556   {
33557     try {
33558       result = Dali::Actor::New();
33559     } catch (std::out_of_range& e) {
33560       {
33561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33562       };
33563     } catch (std::exception& e) {
33564       {
33565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33566       };
33567     } catch (Dali::DaliException e) {
33568       {
33569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33570       };
33571     } catch (...) {
33572       {
33573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33574       };
33575     }
33576   }
33577
33578   jresult = new Dali::Actor((const Dali::Actor &)result);
33579   return jresult;
33580 }
33581
33582
33583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33584   void * jresult ;
33585   Dali::BaseHandle arg1 ;
33586   Dali::BaseHandle *argp1 ;
33587   Dali::Actor result;
33588
33589   argp1 = (Dali::BaseHandle *)jarg1;
33590   if (!argp1) {
33591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33592     return 0;
33593   }
33594   arg1 = *argp1;
33595   {
33596     try {
33597       result = Dali::Actor::DownCast(arg1);
33598     } catch (std::out_of_range& e) {
33599       {
33600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33601       };
33602     } catch (std::exception& e) {
33603       {
33604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33605       };
33606     } catch (Dali::DaliException e) {
33607       {
33608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33609       };
33610     } catch (...) {
33611       {
33612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33613       };
33614     }
33615   }
33616
33617   jresult = new Dali::Actor((const Dali::Actor &)result);
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33624
33625   arg1 = (Dali::Actor *)jarg1;
33626   {
33627     try {
33628       delete arg1;
33629     } catch (std::out_of_range& e) {
33630       {
33631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33632       };
33633     } catch (std::exception& e) {
33634       {
33635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33636       };
33637     } catch (Dali::DaliException e) {
33638       {
33639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33640       };
33641     } catch (...) {
33642       {
33643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33644       };
33645     }
33646   }
33647
33648 }
33649
33650
33651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33652   void * jresult ;
33653   Dali::Actor *arg1 = 0 ;
33654   Dali::Actor *result = 0 ;
33655
33656   arg1 = (Dali::Actor *)jarg1;
33657   if (!arg1) {
33658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33659     return 0;
33660   }
33661   {
33662     try {
33663       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33664     } catch (std::out_of_range& e) {
33665       {
33666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33667       };
33668     } catch (std::exception& e) {
33669       {
33670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33671       };
33672     } catch (Dali::DaliException e) {
33673       {
33674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33675       };
33676     } catch (...) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33679       };
33680     }
33681   }
33682
33683   jresult = (void *)result;
33684   return jresult;
33685 }
33686
33687
33688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33689   void * jresult ;
33690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33691   Dali::Actor *arg2 = 0 ;
33692   Dali::Actor *result = 0 ;
33693
33694   arg1 = (Dali::Actor *)jarg1;
33695   arg2 = (Dali::Actor *)jarg2;
33696   if (!arg2) {
33697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33698     return 0;
33699   }
33700   {
33701     try {
33702       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33703     } catch (std::out_of_range& e) {
33704       {
33705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (std::exception& e) {
33708       {
33709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (Dali::DaliException e) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33714       };
33715     } catch (...) {
33716       {
33717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33718       };
33719     }
33720   }
33721
33722   jresult = (void *)result;
33723   return jresult;
33724 }
33725
33726
33727 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33728   char * jresult ;
33729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33730   std::string *result = 0 ;
33731
33732   arg1 = (Dali::Actor *)jarg1;
33733   {
33734     try {
33735       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33736     } catch (std::out_of_range& e) {
33737       {
33738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33739       };
33740     } catch (std::exception& e) {
33741       {
33742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33743       };
33744     } catch (Dali::DaliException e) {
33745       {
33746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33747       };
33748     } catch (...) {
33749       {
33750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33751       };
33752     }
33753   }
33754
33755   jresult = SWIG_csharp_string_callback(result->c_str());
33756   return jresult;
33757 }
33758
33759
33760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33762   std::string *arg2 = 0 ;
33763
33764   arg1 = (Dali::Actor *)jarg1;
33765   if (!jarg2) {
33766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33767     return ;
33768   }
33769   std::string arg2_str(jarg2);
33770   arg2 = &arg2_str;
33771   {
33772     try {
33773       (arg1)->SetName((std::string const &)*arg2);
33774     } catch (std::out_of_range& e) {
33775       {
33776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33777       };
33778     } catch (std::exception& e) {
33779       {
33780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33781       };
33782     } catch (Dali::DaliException e) {
33783       {
33784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33785       };
33786     } catch (...) {
33787       {
33788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33789       };
33790     }
33791   }
33792
33793
33794   //argout typemap for const std::string&
33795
33796 }
33797
33798
33799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33800   unsigned int jresult ;
33801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33802   unsigned int result;
33803
33804   arg1 = (Dali::Actor *)jarg1;
33805   {
33806     try {
33807       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33808     } catch (std::out_of_range& e) {
33809       {
33810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (std::exception& e) {
33813       {
33814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33815       };
33816     } catch (Dali::DaliException e) {
33817       {
33818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33819       };
33820     } catch (...) {
33821       {
33822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33823       };
33824     }
33825   }
33826
33827   jresult = result;
33828   return jresult;
33829 }
33830
33831
33832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33833   unsigned int jresult ;
33834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33835   bool result;
33836
33837   arg1 = (Dali::Actor *)jarg1;
33838   {
33839     try {
33840       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33841     } catch (std::out_of_range& e) {
33842       {
33843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33844       };
33845     } catch (std::exception& e) {
33846       {
33847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33848       };
33849     } catch (Dali::DaliException e) {
33850       {
33851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33852       };
33853     } catch (...) {
33854       {
33855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33856       };
33857     }
33858   }
33859
33860   jresult = result;
33861   return jresult;
33862 }
33863
33864
33865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33866   unsigned int jresult ;
33867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33868   bool result;
33869
33870   arg1 = (Dali::Actor *)jarg1;
33871   {
33872     try {
33873       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33874     } catch (std::out_of_range& e) {
33875       {
33876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33877       };
33878     } catch (std::exception& e) {
33879       {
33880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33881       };
33882     } catch (Dali::DaliException e) {
33883       {
33884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33885       };
33886     } catch (...) {
33887       {
33888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33889       };
33890     }
33891   }
33892
33893   jresult = result;
33894   return jresult;
33895 }
33896
33897
33898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33899   unsigned int jresult ;
33900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33901   bool result;
33902
33903   arg1 = (Dali::Actor *)jarg1;
33904   {
33905     try {
33906       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33907     } catch (std::out_of_range& e) {
33908       {
33909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33910       };
33911     } catch (std::exception& e) {
33912       {
33913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33914       };
33915     } catch (Dali::DaliException e) {
33916       {
33917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33918       };
33919     } catch (...) {
33920       {
33921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33922       };
33923     }
33924   }
33925
33926   jresult = result;
33927   return jresult;
33928 }
33929
33930
33931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33932   void * jresult ;
33933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33934   Dali::Layer result;
33935
33936   arg1 = (Dali::Actor *)jarg1;
33937   {
33938     try {
33939       result = (arg1)->GetLayer();
33940     } catch (std::out_of_range& e) {
33941       {
33942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33943       };
33944     } catch (std::exception& e) {
33945       {
33946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33947       };
33948     } catch (Dali::DaliException e) {
33949       {
33950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33951       };
33952     } catch (...) {
33953       {
33954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33955       };
33956     }
33957   }
33958
33959   jresult = new Dali::Layer((const Dali::Layer &)result);
33960   return jresult;
33961 }
33962
33963
33964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33966   Dali::Actor arg2 ;
33967   Dali::Actor *argp2 ;
33968
33969   arg1 = (Dali::Actor *)jarg1;
33970   argp2 = (Dali::Actor *)jarg2;
33971   if (!argp2) {
33972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33973     return ;
33974   }
33975   arg2 = *argp2;
33976   {
33977     try {
33978       (arg1)->Add(arg2);
33979     } catch (std::out_of_range& e) {
33980       {
33981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33982       };
33983     } catch (std::exception& e) {
33984       {
33985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33986       };
33987     } catch (Dali::DaliException e) {
33988       {
33989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33990       };
33991     } catch (...) {
33992       {
33993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33994       };
33995     }
33996   }
33997
33998 }
33999
34000
34001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34003   Dali::Actor arg2 ;
34004   Dali::Actor *argp2 ;
34005
34006   arg1 = (Dali::Actor *)jarg1;
34007   argp2 = (Dali::Actor *)jarg2;
34008   if (!argp2) {
34009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34010     return ;
34011   }
34012   arg2 = *argp2;
34013   {
34014     try {
34015       (arg1)->Remove(arg2);
34016     } catch (std::out_of_range& e) {
34017       {
34018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34019       };
34020     } catch (std::exception& e) {
34021       {
34022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34023       };
34024     } catch (Dali::DaliException e) {
34025       {
34026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34027       };
34028     } catch (...) {
34029       {
34030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34031       };
34032     }
34033   }
34034
34035 }
34036
34037
34038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34040
34041   arg1 = (Dali::Actor *)jarg1;
34042   {
34043     try {
34044       (arg1)->Unparent();
34045     } catch (std::out_of_range& e) {
34046       {
34047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34048       };
34049     } catch (std::exception& e) {
34050       {
34051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34052       };
34053     } catch (Dali::DaliException e) {
34054       {
34055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34056       };
34057     } catch (...) {
34058       {
34059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34060       };
34061     }
34062   }
34063
34064 }
34065
34066
34067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34068   unsigned int jresult ;
34069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34070   unsigned int result;
34071
34072   arg1 = (Dali::Actor *)jarg1;
34073   {
34074     try {
34075       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34076     } catch (std::out_of_range& e) {
34077       {
34078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34079       };
34080     } catch (std::exception& e) {
34081       {
34082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34083       };
34084     } catch (Dali::DaliException e) {
34085       {
34086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34087       };
34088     } catch (...) {
34089       {
34090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34091       };
34092     }
34093   }
34094
34095   jresult = result;
34096   return jresult;
34097 }
34098
34099
34100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34101   void * jresult ;
34102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34103   unsigned int arg2 ;
34104   Dali::Actor result;
34105
34106   arg1 = (Dali::Actor *)jarg1;
34107   arg2 = (unsigned int)jarg2;
34108   {
34109     try {
34110       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34111     } catch (std::out_of_range& e) {
34112       {
34113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34114       };
34115     } catch (std::exception& e) {
34116       {
34117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34118       };
34119     } catch (Dali::DaliException e) {
34120       {
34121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34122       };
34123     } catch (...) {
34124       {
34125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34126       };
34127     }
34128   }
34129
34130   jresult = new Dali::Actor((const Dali::Actor &)result);
34131   return jresult;
34132 }
34133
34134
34135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34136   void * jresult ;
34137   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34138   std::string *arg2 = 0 ;
34139   Dali::Actor result;
34140
34141   arg1 = (Dali::Actor *)jarg1;
34142   if (!jarg2) {
34143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34144     return 0;
34145   }
34146   std::string arg2_str(jarg2);
34147   arg2 = &arg2_str;
34148   {
34149     try {
34150       result = (arg1)->FindChildByName((std::string const &)*arg2);
34151     } catch (std::out_of_range& e) {
34152       {
34153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34154       };
34155     } catch (std::exception& e) {
34156       {
34157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34158       };
34159     } catch (Dali::DaliException e) {
34160       {
34161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34162       };
34163     } catch (...) {
34164       {
34165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34166       };
34167     }
34168   }
34169
34170   jresult = new Dali::Actor((const Dali::Actor &)result);
34171
34172   //argout typemap for const std::string&
34173
34174   return jresult;
34175 }
34176
34177
34178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34179   void * jresult ;
34180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34181   unsigned int arg2 ;
34182   Dali::Actor result;
34183
34184   arg1 = (Dali::Actor *)jarg1;
34185   arg2 = (unsigned int)jarg2;
34186   {
34187     try {
34188       result = (arg1)->FindChildById(arg2);
34189     } catch (std::out_of_range& e) {
34190       {
34191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34192       };
34193     } catch (std::exception& e) {
34194       {
34195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34196       };
34197     } catch (Dali::DaliException e) {
34198       {
34199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34200       };
34201     } catch (...) {
34202       {
34203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34204       };
34205     }
34206   }
34207
34208   jresult = new Dali::Actor((const Dali::Actor &)result);
34209   return jresult;
34210 }
34211
34212
34213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34214   void * jresult ;
34215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34216   Dali::Actor result;
34217
34218   arg1 = (Dali::Actor *)jarg1;
34219   {
34220     try {
34221       result = ((Dali::Actor const *)arg1)->GetParent();
34222     } catch (std::out_of_range& e) {
34223       {
34224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34225       };
34226     } catch (std::exception& e) {
34227       {
34228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34229       };
34230     } catch (Dali::DaliException e) {
34231       {
34232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34233       };
34234     } catch (...) {
34235       {
34236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34237       };
34238     }
34239   }
34240
34241   jresult = new Dali::Actor((const Dali::Actor &)result);
34242   return jresult;
34243 }
34244
34245
34246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34247   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34248   Dali::Vector3 *arg2 = 0 ;
34249
34250   arg1 = (Dali::Actor *)jarg1;
34251   arg2 = (Dali::Vector3 *)jarg2;
34252   if (!arg2) {
34253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34254     return ;
34255   }
34256   {
34257     try {
34258       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34259     } catch (std::out_of_range& e) {
34260       {
34261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34262       };
34263     } catch (std::exception& e) {
34264       {
34265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34266       };
34267     } catch (Dali::DaliException e) {
34268       {
34269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34270       };
34271     } catch (...) {
34272       {
34273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34274       };
34275     }
34276   }
34277
34278 }
34279
34280
34281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34282   void * jresult ;
34283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34284   Dali::Vector3 result;
34285
34286   arg1 = (Dali::Actor *)jarg1;
34287   {
34288     try {
34289       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34290     } catch (std::out_of_range& e) {
34291       {
34292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34293       };
34294     } catch (std::exception& e) {
34295       {
34296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34297       };
34298     } catch (Dali::DaliException e) {
34299       {
34300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34301       };
34302     } catch (...) {
34303       {
34304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34305       };
34306     }
34307   }
34308
34309   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34310   return jresult;
34311 }
34312
34313
34314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34316   Dali::Vector3 *arg2 = 0 ;
34317
34318   arg1 = (Dali::Actor *)jarg1;
34319   arg2 = (Dali::Vector3 *)jarg2;
34320   if (!arg2) {
34321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34322     return ;
34323   }
34324   {
34325     try {
34326       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34327     } catch (std::out_of_range& e) {
34328       {
34329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34330       };
34331     } catch (std::exception& e) {
34332       {
34333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34334       };
34335     } catch (Dali::DaliException e) {
34336       {
34337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34338       };
34339     } catch (...) {
34340       {
34341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34342       };
34343     }
34344   }
34345
34346 }
34347
34348
34349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34350   void * jresult ;
34351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34352   Dali::Vector3 result;
34353
34354   arg1 = (Dali::Actor *)jarg1;
34355   {
34356     try {
34357       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34358     } catch (std::out_of_range& e) {
34359       {
34360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34361       };
34362     } catch (std::exception& e) {
34363       {
34364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34365       };
34366     } catch (Dali::DaliException e) {
34367       {
34368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34369       };
34370     } catch (...) {
34371       {
34372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34373       };
34374     }
34375   }
34376
34377   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34378   return jresult;
34379 }
34380
34381
34382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34383   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34384   float arg2 ;
34385   float arg3 ;
34386
34387   arg1 = (Dali::Actor *)jarg1;
34388   arg2 = (float)jarg2;
34389   arg3 = (float)jarg3;
34390   {
34391     try {
34392       (arg1)->SetSize(arg2,arg3);
34393     } catch (std::out_of_range& e) {
34394       {
34395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34396       };
34397     } catch (std::exception& e) {
34398       {
34399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34400       };
34401     } catch (Dali::DaliException e) {
34402       {
34403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34404       };
34405     } catch (...) {
34406       {
34407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34408       };
34409     }
34410   }
34411
34412 }
34413
34414
34415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34417   float arg2 ;
34418   float arg3 ;
34419   float arg4 ;
34420
34421   arg1 = (Dali::Actor *)jarg1;
34422   arg2 = (float)jarg2;
34423   arg3 = (float)jarg3;
34424   arg4 = (float)jarg4;
34425   {
34426     try {
34427       (arg1)->SetSize(arg2,arg3,arg4);
34428     } catch (std::out_of_range& e) {
34429       {
34430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34431       };
34432     } catch (std::exception& e) {
34433       {
34434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34435       };
34436     } catch (Dali::DaliException e) {
34437       {
34438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34439       };
34440     } catch (...) {
34441       {
34442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34443       };
34444     }
34445   }
34446
34447 }
34448
34449
34450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34452   Dali::Vector2 *arg2 = 0 ;
34453
34454   arg1 = (Dali::Actor *)jarg1;
34455   arg2 = (Dali::Vector2 *)jarg2;
34456   if (!arg2) {
34457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34458     return ;
34459   }
34460   {
34461     try {
34462       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34463     } catch (std::out_of_range& e) {
34464       {
34465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34466       };
34467     } catch (std::exception& e) {
34468       {
34469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34470       };
34471     } catch (Dali::DaliException e) {
34472       {
34473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34474       };
34475     } catch (...) {
34476       {
34477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34478       };
34479     }
34480   }
34481
34482 }
34483
34484
34485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34486   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34487   Dali::Vector3 *arg2 = 0 ;
34488
34489   arg1 = (Dali::Actor *)jarg1;
34490   arg2 = (Dali::Vector3 *)jarg2;
34491   if (!arg2) {
34492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34493     return ;
34494   }
34495   {
34496     try {
34497       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34498     } catch (std::out_of_range& e) {
34499       {
34500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34501       };
34502     } catch (std::exception& e) {
34503       {
34504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34505       };
34506     } catch (Dali::DaliException e) {
34507       {
34508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34509       };
34510     } catch (...) {
34511       {
34512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34513       };
34514     }
34515   }
34516
34517 }
34518
34519
34520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34521   void * jresult ;
34522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34523   Dali::Vector3 result;
34524
34525   arg1 = (Dali::Actor *)jarg1;
34526   {
34527     try {
34528       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34529     } catch (std::out_of_range& e) {
34530       {
34531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34532       };
34533     } catch (std::exception& e) {
34534       {
34535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34536       };
34537     } catch (Dali::DaliException e) {
34538       {
34539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34540       };
34541     } catch (...) {
34542       {
34543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34544       };
34545     }
34546   }
34547
34548   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34549   return jresult;
34550 }
34551
34552
34553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34554   void * jresult ;
34555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34556   Dali::Vector3 result;
34557
34558   arg1 = (Dali::Actor *)jarg1;
34559   {
34560     try {
34561       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34562     } catch (std::out_of_range& e) {
34563       {
34564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34565       };
34566     } catch (std::exception& e) {
34567       {
34568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34569       };
34570     } catch (Dali::DaliException e) {
34571       {
34572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34573       };
34574     } catch (...) {
34575       {
34576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34577       };
34578     }
34579   }
34580
34581   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34582   return jresult;
34583 }
34584
34585
34586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34587   void * jresult ;
34588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34589   Dali::Vector3 result;
34590
34591   arg1 = (Dali::Actor *)jarg1;
34592   {
34593     try {
34594       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34595     } catch (std::out_of_range& e) {
34596       {
34597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34598       };
34599     } catch (std::exception& e) {
34600       {
34601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34602       };
34603     } catch (Dali::DaliException e) {
34604       {
34605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34606       };
34607     } catch (...) {
34608       {
34609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34610       };
34611     }
34612   }
34613
34614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34615   return jresult;
34616 }
34617
34618
34619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34621   float arg2 ;
34622   float arg3 ;
34623
34624   arg1 = (Dali::Actor *)jarg1;
34625   arg2 = (float)jarg2;
34626   arg3 = (float)jarg3;
34627   {
34628     try {
34629       (arg1)->SetPosition(arg2,arg3);
34630     } catch (std::out_of_range& e) {
34631       {
34632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34633       };
34634     } catch (std::exception& e) {
34635       {
34636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34637       };
34638     } catch (Dali::DaliException e) {
34639       {
34640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34641       };
34642     } catch (...) {
34643       {
34644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34645       };
34646     }
34647   }
34648
34649 }
34650
34651
34652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34654   float arg2 ;
34655   float arg3 ;
34656   float arg4 ;
34657
34658   arg1 = (Dali::Actor *)jarg1;
34659   arg2 = (float)jarg2;
34660   arg3 = (float)jarg3;
34661   arg4 = (float)jarg4;
34662   {
34663     try {
34664       (arg1)->SetPosition(arg2,arg3,arg4);
34665     } catch (std::out_of_range& e) {
34666       {
34667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34668       };
34669     } catch (std::exception& e) {
34670       {
34671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34672       };
34673     } catch (Dali::DaliException e) {
34674       {
34675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34676       };
34677     } catch (...) {
34678       {
34679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34680       };
34681     }
34682   }
34683
34684 }
34685
34686
34687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34689   Dali::Vector3 *arg2 = 0 ;
34690
34691   arg1 = (Dali::Actor *)jarg1;
34692   arg2 = (Dali::Vector3 *)jarg2;
34693   if (!arg2) {
34694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34695     return ;
34696   }
34697   {
34698     try {
34699       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34700     } catch (std::out_of_range& e) {
34701       {
34702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34703       };
34704     } catch (std::exception& e) {
34705       {
34706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34707       };
34708     } catch (Dali::DaliException e) {
34709       {
34710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34711       };
34712     } catch (...) {
34713       {
34714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34715       };
34716     }
34717   }
34718
34719 }
34720
34721
34722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34724   float arg2 ;
34725
34726   arg1 = (Dali::Actor *)jarg1;
34727   arg2 = (float)jarg2;
34728   {
34729     try {
34730       (arg1)->SetX(arg2);
34731     } catch (std::out_of_range& e) {
34732       {
34733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34734       };
34735     } catch (std::exception& e) {
34736       {
34737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34738       };
34739     } catch (Dali::DaliException e) {
34740       {
34741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34742       };
34743     } catch (...) {
34744       {
34745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34746       };
34747     }
34748   }
34749
34750 }
34751
34752
34753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34755   float arg2 ;
34756
34757   arg1 = (Dali::Actor *)jarg1;
34758   arg2 = (float)jarg2;
34759   {
34760     try {
34761       (arg1)->SetY(arg2);
34762     } catch (std::out_of_range& e) {
34763       {
34764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34765       };
34766     } catch (std::exception& e) {
34767       {
34768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34769       };
34770     } catch (Dali::DaliException e) {
34771       {
34772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34773       };
34774     } catch (...) {
34775       {
34776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34777       };
34778     }
34779   }
34780
34781 }
34782
34783
34784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34786   float arg2 ;
34787
34788   arg1 = (Dali::Actor *)jarg1;
34789   arg2 = (float)jarg2;
34790   {
34791     try {
34792       (arg1)->SetZ(arg2);
34793     } catch (std::out_of_range& e) {
34794       {
34795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34796       };
34797     } catch (std::exception& e) {
34798       {
34799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34800       };
34801     } catch (Dali::DaliException e) {
34802       {
34803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34804       };
34805     } catch (...) {
34806       {
34807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34808       };
34809     }
34810   }
34811
34812 }
34813
34814
34815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34817   Dali::Vector3 *arg2 = 0 ;
34818
34819   arg1 = (Dali::Actor *)jarg1;
34820   arg2 = (Dali::Vector3 *)jarg2;
34821   if (!arg2) {
34822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34823     return ;
34824   }
34825   {
34826     try {
34827       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34828     } catch (std::out_of_range& e) {
34829       {
34830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34831       };
34832     } catch (std::exception& e) {
34833       {
34834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34835       };
34836     } catch (Dali::DaliException e) {
34837       {
34838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34839       };
34840     } catch (...) {
34841       {
34842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34843       };
34844     }
34845   }
34846
34847 }
34848
34849
34850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34851   void * jresult ;
34852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34853   Dali::Vector3 result;
34854
34855   arg1 = (Dali::Actor *)jarg1;
34856   {
34857     try {
34858       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34859     } catch (std::out_of_range& e) {
34860       {
34861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34862       };
34863     } catch (std::exception& e) {
34864       {
34865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34866       };
34867     } catch (Dali::DaliException e) {
34868       {
34869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34870       };
34871     } catch (...) {
34872       {
34873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34874       };
34875     }
34876   }
34877
34878   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34879   return jresult;
34880 }
34881
34882
34883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34884   void * jresult ;
34885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34886   Dali::Vector3 result;
34887
34888   arg1 = (Dali::Actor *)jarg1;
34889   {
34890     try {
34891       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34892     } catch (std::out_of_range& e) {
34893       {
34894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34895       };
34896     } catch (std::exception& e) {
34897       {
34898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34899       };
34900     } catch (Dali::DaliException e) {
34901       {
34902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34903       };
34904     } catch (...) {
34905       {
34906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34907       };
34908     }
34909   }
34910
34911   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34912   return jresult;
34913 }
34914
34915
34916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34918   bool arg2 ;
34919
34920   arg1 = (Dali::Actor *)jarg1;
34921   arg2 = jarg2 ? true : false;
34922   {
34923     try {
34924       (arg1)->SetInheritPosition(arg2);
34925     } catch (std::out_of_range& e) {
34926       {
34927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34928       };
34929     } catch (std::exception& e) {
34930       {
34931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34932       };
34933     } catch (Dali::DaliException e) {
34934       {
34935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34936       };
34937     } catch (...) {
34938       {
34939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34940       };
34941     }
34942   }
34943
34944 }
34945
34946
34947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34948   unsigned int jresult ;
34949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34950   bool result;
34951
34952   arg1 = (Dali::Actor *)jarg1;
34953   {
34954     try {
34955       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34956     } catch (std::out_of_range& e) {
34957       {
34958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34959       };
34960     } catch (std::exception& e) {
34961       {
34962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34963       };
34964     } catch (Dali::DaliException e) {
34965       {
34966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34967       };
34968     } catch (...) {
34969       {
34970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34971       };
34972     }
34973   }
34974
34975   jresult = result;
34976   return jresult;
34977 }
34978
34979
34980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34982   Dali::Degree *arg2 = 0 ;
34983   Dali::Vector3 *arg3 = 0 ;
34984
34985   arg1 = (Dali::Actor *)jarg1;
34986   arg2 = (Dali::Degree *)jarg2;
34987   if (!arg2) {
34988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34989     return ;
34990   }
34991   arg3 = (Dali::Vector3 *)jarg3;
34992   if (!arg3) {
34993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34994     return ;
34995   }
34996   {
34997     try {
34998       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34999     } catch (std::out_of_range& e) {
35000       {
35001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35002       };
35003     } catch (std::exception& e) {
35004       {
35005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35006       };
35007     } catch (Dali::DaliException e) {
35008       {
35009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35010       };
35011     } catch (...) {
35012       {
35013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35014       };
35015     }
35016   }
35017
35018 }
35019
35020
35021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35022   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35023   Dali::Radian *arg2 = 0 ;
35024   Dali::Vector3 *arg3 = 0 ;
35025
35026   arg1 = (Dali::Actor *)jarg1;
35027   arg2 = (Dali::Radian *)jarg2;
35028   if (!arg2) {
35029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35030     return ;
35031   }
35032   arg3 = (Dali::Vector3 *)jarg3;
35033   if (!arg3) {
35034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35035     return ;
35036   }
35037   {
35038     try {
35039       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35040     } catch (std::out_of_range& e) {
35041       {
35042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35043       };
35044     } catch (std::exception& e) {
35045       {
35046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35047       };
35048     } catch (Dali::DaliException e) {
35049       {
35050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35051       };
35052     } catch (...) {
35053       {
35054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35055       };
35056     }
35057   }
35058
35059 }
35060
35061
35062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35063   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35064   Dali::Quaternion *arg2 = 0 ;
35065
35066   arg1 = (Dali::Actor *)jarg1;
35067   arg2 = (Dali::Quaternion *)jarg2;
35068   if (!arg2) {
35069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35070     return ;
35071   }
35072   {
35073     try {
35074       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35075     } catch (std::out_of_range& e) {
35076       {
35077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35078       };
35079     } catch (std::exception& e) {
35080       {
35081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35082       };
35083     } catch (Dali::DaliException e) {
35084       {
35085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35086       };
35087     } catch (...) {
35088       {
35089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35090       };
35091     }
35092   }
35093
35094 }
35095
35096
35097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35099   Dali::Degree *arg2 = 0 ;
35100   Dali::Vector3 *arg3 = 0 ;
35101
35102   arg1 = (Dali::Actor *)jarg1;
35103   arg2 = (Dali::Degree *)jarg2;
35104   if (!arg2) {
35105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35106     return ;
35107   }
35108   arg3 = (Dali::Vector3 *)jarg3;
35109   if (!arg3) {
35110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35111     return ;
35112   }
35113   {
35114     try {
35115       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35116     } catch (std::out_of_range& e) {
35117       {
35118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35119       };
35120     } catch (std::exception& e) {
35121       {
35122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35123       };
35124     } catch (Dali::DaliException e) {
35125       {
35126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35127       };
35128     } catch (...) {
35129       {
35130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35131       };
35132     }
35133   }
35134
35135 }
35136
35137
35138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35140   Dali::Radian *arg2 = 0 ;
35141   Dali::Vector3 *arg3 = 0 ;
35142
35143   arg1 = (Dali::Actor *)jarg1;
35144   arg2 = (Dali::Radian *)jarg2;
35145   if (!arg2) {
35146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35147     return ;
35148   }
35149   arg3 = (Dali::Vector3 *)jarg3;
35150   if (!arg3) {
35151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35152     return ;
35153   }
35154   {
35155     try {
35156       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35157     } catch (std::out_of_range& e) {
35158       {
35159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35160       };
35161     } catch (std::exception& e) {
35162       {
35163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35164       };
35165     } catch (Dali::DaliException e) {
35166       {
35167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35168       };
35169     } catch (...) {
35170       {
35171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35172       };
35173     }
35174   }
35175
35176 }
35177
35178
35179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35181   Dali::Quaternion *arg2 = 0 ;
35182
35183   arg1 = (Dali::Actor *)jarg1;
35184   arg2 = (Dali::Quaternion *)jarg2;
35185   if (!arg2) {
35186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35187     return ;
35188   }
35189   {
35190     try {
35191       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35192     } catch (std::out_of_range& e) {
35193       {
35194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35195       };
35196     } catch (std::exception& e) {
35197       {
35198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35199       };
35200     } catch (Dali::DaliException e) {
35201       {
35202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35203       };
35204     } catch (...) {
35205       {
35206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35207       };
35208     }
35209   }
35210
35211 }
35212
35213
35214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35215   void * jresult ;
35216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35217   Dali::Quaternion result;
35218
35219   arg1 = (Dali::Actor *)jarg1;
35220   {
35221     try {
35222       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35223     } catch (std::out_of_range& e) {
35224       {
35225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35226       };
35227     } catch (std::exception& e) {
35228       {
35229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35230       };
35231     } catch (Dali::DaliException e) {
35232       {
35233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35234       };
35235     } catch (...) {
35236       {
35237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35238       };
35239     }
35240   }
35241
35242   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35243   return jresult;
35244 }
35245
35246
35247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35248   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35249   bool arg2 ;
35250
35251   arg1 = (Dali::Actor *)jarg1;
35252   arg2 = jarg2 ? true : false;
35253   {
35254     try {
35255       (arg1)->SetInheritOrientation(arg2);
35256     } catch (std::out_of_range& e) {
35257       {
35258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35259       };
35260     } catch (std::exception& e) {
35261       {
35262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35263       };
35264     } catch (Dali::DaliException e) {
35265       {
35266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35267       };
35268     } catch (...) {
35269       {
35270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35271       };
35272     }
35273   }
35274
35275 }
35276
35277
35278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35279   unsigned int jresult ;
35280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35281   bool result;
35282
35283   arg1 = (Dali::Actor *)jarg1;
35284   {
35285     try {
35286       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35287     } catch (std::out_of_range& e) {
35288       {
35289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35290       };
35291     } catch (std::exception& e) {
35292       {
35293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35294       };
35295     } catch (Dali::DaliException e) {
35296       {
35297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35298       };
35299     } catch (...) {
35300       {
35301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35302       };
35303     }
35304   }
35305
35306   jresult = result;
35307   return jresult;
35308 }
35309
35310
35311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35312   void * jresult ;
35313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35314   Dali::Quaternion result;
35315
35316   arg1 = (Dali::Actor *)jarg1;
35317   {
35318     try {
35319       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35320     } catch (std::out_of_range& e) {
35321       {
35322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35323       };
35324     } catch (std::exception& e) {
35325       {
35326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35327       };
35328     } catch (Dali::DaliException e) {
35329       {
35330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35331       };
35332     } catch (...) {
35333       {
35334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35335       };
35336     }
35337   }
35338
35339   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35340   return jresult;
35341 }
35342
35343
35344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35346   float arg2 ;
35347
35348   arg1 = (Dali::Actor *)jarg1;
35349   arg2 = (float)jarg2;
35350   {
35351     try {
35352       (arg1)->SetScale(arg2);
35353     } catch (std::out_of_range& e) {
35354       {
35355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35356       };
35357     } catch (std::exception& e) {
35358       {
35359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35360       };
35361     } catch (Dali::DaliException e) {
35362       {
35363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35364       };
35365     } catch (...) {
35366       {
35367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35368       };
35369     }
35370   }
35371
35372 }
35373
35374
35375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35376   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35377   float arg2 ;
35378   float arg3 ;
35379   float arg4 ;
35380
35381   arg1 = (Dali::Actor *)jarg1;
35382   arg2 = (float)jarg2;
35383   arg3 = (float)jarg3;
35384   arg4 = (float)jarg4;
35385   {
35386     try {
35387       (arg1)->SetScale(arg2,arg3,arg4);
35388     } catch (std::out_of_range& e) {
35389       {
35390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35391       };
35392     } catch (std::exception& e) {
35393       {
35394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35395       };
35396     } catch (Dali::DaliException e) {
35397       {
35398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35399       };
35400     } catch (...) {
35401       {
35402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35403       };
35404     }
35405   }
35406
35407 }
35408
35409
35410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35412   Dali::Vector3 *arg2 = 0 ;
35413
35414   arg1 = (Dali::Actor *)jarg1;
35415   arg2 = (Dali::Vector3 *)jarg2;
35416   if (!arg2) {
35417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35418     return ;
35419   }
35420   {
35421     try {
35422       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35423     } catch (std::out_of_range& e) {
35424       {
35425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35426       };
35427     } catch (std::exception& e) {
35428       {
35429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35430       };
35431     } catch (Dali::DaliException e) {
35432       {
35433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35434       };
35435     } catch (...) {
35436       {
35437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35438       };
35439     }
35440   }
35441
35442 }
35443
35444
35445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35446   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35447   Dali::Vector3 *arg2 = 0 ;
35448
35449   arg1 = (Dali::Actor *)jarg1;
35450   arg2 = (Dali::Vector3 *)jarg2;
35451   if (!arg2) {
35452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35453     return ;
35454   }
35455   {
35456     try {
35457       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35458     } catch (std::out_of_range& e) {
35459       {
35460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35461       };
35462     } catch (std::exception& e) {
35463       {
35464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35465       };
35466     } catch (Dali::DaliException e) {
35467       {
35468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35469       };
35470     } catch (...) {
35471       {
35472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35473       };
35474     }
35475   }
35476
35477 }
35478
35479
35480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35481   void * jresult ;
35482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35483   Dali::Vector3 result;
35484
35485   arg1 = (Dali::Actor *)jarg1;
35486   {
35487     try {
35488       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35489     } catch (std::out_of_range& e) {
35490       {
35491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35492       };
35493     } catch (std::exception& e) {
35494       {
35495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35496       };
35497     } catch (Dali::DaliException e) {
35498       {
35499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35500       };
35501     } catch (...) {
35502       {
35503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35504       };
35505     }
35506   }
35507
35508   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35509   return jresult;
35510 }
35511
35512
35513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35514   void * jresult ;
35515   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35516   Dali::Vector3 result;
35517
35518   arg1 = (Dali::Actor *)jarg1;
35519   {
35520     try {
35521       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35522     } catch (std::out_of_range& e) {
35523       {
35524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35525       };
35526     } catch (std::exception& e) {
35527       {
35528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35529       };
35530     } catch (Dali::DaliException e) {
35531       {
35532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35533       };
35534     } catch (...) {
35535       {
35536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35537       };
35538     }
35539   }
35540
35541   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35542   return jresult;
35543 }
35544
35545
35546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35548   bool arg2 ;
35549
35550   arg1 = (Dali::Actor *)jarg1;
35551   arg2 = jarg2 ? true : false;
35552   {
35553     try {
35554       (arg1)->SetInheritScale(arg2);
35555     } catch (std::out_of_range& e) {
35556       {
35557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35558       };
35559     } catch (std::exception& e) {
35560       {
35561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35562       };
35563     } catch (Dali::DaliException e) {
35564       {
35565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35566       };
35567     } catch (...) {
35568       {
35569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35570       };
35571     }
35572   }
35573
35574 }
35575
35576
35577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35578   unsigned int jresult ;
35579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35580   bool result;
35581
35582   arg1 = (Dali::Actor *)jarg1;
35583   {
35584     try {
35585       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35586     } catch (std::out_of_range& e) {
35587       {
35588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35589       };
35590     } catch (std::exception& e) {
35591       {
35592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35593       };
35594     } catch (Dali::DaliException e) {
35595       {
35596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35597       };
35598     } catch (...) {
35599       {
35600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35601       };
35602     }
35603   }
35604
35605   jresult = result;
35606   return jresult;
35607 }
35608
35609
35610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35611   void * jresult ;
35612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35613   Dali::Matrix result;
35614
35615   arg1 = (Dali::Actor *)jarg1;
35616   {
35617     try {
35618       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35619     } catch (std::out_of_range& e) {
35620       {
35621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35622       };
35623     } catch (std::exception& e) {
35624       {
35625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35626       };
35627     } catch (Dali::DaliException e) {
35628       {
35629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35630       };
35631     } catch (...) {
35632       {
35633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35634       };
35635     }
35636   }
35637
35638   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35639   return jresult;
35640 }
35641
35642
35643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35645   bool arg2 ;
35646
35647   arg1 = (Dali::Actor *)jarg1;
35648   arg2 = jarg2 ? true : false;
35649   {
35650     try {
35651       (arg1)->SetVisible(arg2);
35652     } catch (std::out_of_range& e) {
35653       {
35654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35655       };
35656     } catch (std::exception& e) {
35657       {
35658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35659       };
35660     } catch (Dali::DaliException e) {
35661       {
35662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35663       };
35664     } catch (...) {
35665       {
35666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35667       };
35668     }
35669   }
35670
35671 }
35672
35673
35674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35675   unsigned int jresult ;
35676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35677   bool result;
35678
35679   arg1 = (Dali::Actor *)jarg1;
35680   {
35681     try {
35682       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35683     } catch (std::out_of_range& e) {
35684       {
35685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35686       };
35687     } catch (std::exception& e) {
35688       {
35689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35690       };
35691     } catch (Dali::DaliException e) {
35692       {
35693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35694       };
35695     } catch (...) {
35696       {
35697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35698       };
35699     }
35700   }
35701
35702   jresult = result;
35703   return jresult;
35704 }
35705
35706
35707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35709   float arg2 ;
35710
35711   arg1 = (Dali::Actor *)jarg1;
35712   arg2 = (float)jarg2;
35713   {
35714     try {
35715       (arg1)->SetOpacity(arg2);
35716     } catch (std::out_of_range& e) {
35717       {
35718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35719       };
35720     } catch (std::exception& e) {
35721       {
35722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35723       };
35724     } catch (Dali::DaliException e) {
35725       {
35726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35727       };
35728     } catch (...) {
35729       {
35730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35731       };
35732     }
35733   }
35734
35735 }
35736
35737
35738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35739   float jresult ;
35740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35741   float result;
35742
35743   arg1 = (Dali::Actor *)jarg1;
35744   {
35745     try {
35746       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35747     } catch (std::out_of_range& e) {
35748       {
35749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35750       };
35751     } catch (std::exception& e) {
35752       {
35753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35754       };
35755     } catch (Dali::DaliException e) {
35756       {
35757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35758       };
35759     } catch (...) {
35760       {
35761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35762       };
35763     }
35764   }
35765
35766   jresult = result;
35767   return jresult;
35768 }
35769
35770
35771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35772   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35773   Dali::Vector4 *arg2 = 0 ;
35774
35775   arg1 = (Dali::Actor *)jarg1;
35776   arg2 = (Dali::Vector4 *)jarg2;
35777   if (!arg2) {
35778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35779     return ;
35780   }
35781   {
35782     try {
35783       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35784     } catch (std::out_of_range& e) {
35785       {
35786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35787       };
35788     } catch (std::exception& e) {
35789       {
35790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35791       };
35792     } catch (Dali::DaliException e) {
35793       {
35794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35795       };
35796     } catch (...) {
35797       {
35798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35799       };
35800     }
35801   }
35802
35803 }
35804
35805
35806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35807   void * jresult ;
35808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35809   Dali::Vector4 result;
35810
35811   arg1 = (Dali::Actor *)jarg1;
35812   {
35813     try {
35814       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35815     } catch (std::out_of_range& e) {
35816       {
35817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35818       };
35819     } catch (std::exception& e) {
35820       {
35821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35822       };
35823     } catch (Dali::DaliException e) {
35824       {
35825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35826       };
35827     } catch (...) {
35828       {
35829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35830       };
35831     }
35832   }
35833
35834   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35835   return jresult;
35836 }
35837
35838
35839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35841   Dali::ColorMode arg2 ;
35842
35843   arg1 = (Dali::Actor *)jarg1;
35844   arg2 = (Dali::ColorMode)jarg2;
35845   {
35846     try {
35847       (arg1)->SetColorMode(arg2);
35848     } catch (std::out_of_range& e) {
35849       {
35850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35851       };
35852     } catch (std::exception& e) {
35853       {
35854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35855       };
35856     } catch (Dali::DaliException e) {
35857       {
35858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35859       };
35860     } catch (...) {
35861       {
35862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35863       };
35864     }
35865   }
35866
35867 }
35868
35869
35870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35871   int jresult ;
35872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35873   Dali::ColorMode result;
35874
35875   arg1 = (Dali::Actor *)jarg1;
35876   {
35877     try {
35878       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35879     } catch (std::out_of_range& e) {
35880       {
35881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35882       };
35883     } catch (std::exception& e) {
35884       {
35885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35886       };
35887     } catch (Dali::DaliException e) {
35888       {
35889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35890       };
35891     } catch (...) {
35892       {
35893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35894       };
35895     }
35896   }
35897
35898   jresult = (int)result;
35899   return jresult;
35900 }
35901
35902
35903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35904   void * jresult ;
35905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35906   Dali::Vector4 result;
35907
35908   arg1 = (Dali::Actor *)jarg1;
35909   {
35910     try {
35911       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35912     } catch (std::out_of_range& e) {
35913       {
35914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35915       };
35916     } catch (std::exception& e) {
35917       {
35918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35919       };
35920     } catch (Dali::DaliException e) {
35921       {
35922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35923       };
35924     } catch (...) {
35925       {
35926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35927       };
35928     }
35929   }
35930
35931   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35932   return jresult;
35933 }
35934
35935
35936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35938   Dali::DrawMode::Type arg2 ;
35939
35940   arg1 = (Dali::Actor *)jarg1;
35941   arg2 = (Dali::DrawMode::Type)jarg2;
35942   {
35943     try {
35944       (arg1)->SetDrawMode(arg2);
35945     } catch (std::out_of_range& e) {
35946       {
35947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35948       };
35949     } catch (std::exception& e) {
35950       {
35951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35952       };
35953     } catch (Dali::DaliException e) {
35954       {
35955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35956       };
35957     } catch (...) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35960       };
35961     }
35962   }
35963
35964 }
35965
35966
35967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35968   int jresult ;
35969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35970   Dali::DrawMode::Type result;
35971
35972   arg1 = (Dali::Actor *)jarg1;
35973   {
35974     try {
35975       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35976     } catch (std::out_of_range& e) {
35977       {
35978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35979       };
35980     } catch (std::exception& e) {
35981       {
35982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35983       };
35984     } catch (Dali::DaliException e) {
35985       {
35986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35987       };
35988     } catch (...) {
35989       {
35990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35991       };
35992     }
35993   }
35994
35995   jresult = (int)result;
35996   return jresult;
35997 }
35998
35999
36000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36002   bool arg2 ;
36003
36004   arg1 = (Dali::Actor *)jarg1;
36005   arg2 = jarg2 ? true : false;
36006   {
36007     try {
36008       (arg1)->SetSensitive(arg2);
36009     } catch (std::out_of_range& e) {
36010       {
36011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36012       };
36013     } catch (std::exception& e) {
36014       {
36015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36016       };
36017     } catch (Dali::DaliException e) {
36018       {
36019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36020       };
36021     } catch (...) {
36022       {
36023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36024       };
36025     }
36026   }
36027
36028 }
36029
36030
36031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36032   unsigned int jresult ;
36033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36034   bool result;
36035
36036   arg1 = (Dali::Actor *)jarg1;
36037   {
36038     try {
36039       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36040     } catch (std::out_of_range& e) {
36041       {
36042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36043       };
36044     } catch (std::exception& e) {
36045       {
36046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36047       };
36048     } catch (Dali::DaliException e) {
36049       {
36050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36051       };
36052     } catch (...) {
36053       {
36054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36055       };
36056     }
36057   }
36058
36059   jresult = result;
36060   return jresult;
36061 }
36062
36063
36064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36065   unsigned int jresult ;
36066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36067   float *arg2 = 0 ;
36068   float *arg3 = 0 ;
36069   float arg4 ;
36070   float arg5 ;
36071   bool result;
36072
36073   arg1 = (Dali::Actor *)jarg1;
36074   arg2 = (float *)jarg2;
36075   arg3 = (float *)jarg3;
36076   arg4 = (float)jarg4;
36077   arg5 = (float)jarg5;
36078   {
36079     try {
36080       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36081     } catch (std::out_of_range& e) {
36082       {
36083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36084       };
36085     } catch (std::exception& e) {
36086       {
36087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36088       };
36089     } catch (Dali::DaliException e) {
36090       {
36091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36092       };
36093     } catch (...) {
36094       {
36095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36096       };
36097     }
36098   }
36099
36100   jresult = result;
36101   return jresult;
36102 }
36103
36104
36105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36107   bool arg2 ;
36108
36109   arg1 = (Dali::Actor *)jarg1;
36110   arg2 = jarg2 ? true : false;
36111   {
36112     try {
36113       (arg1)->SetLeaveRequired(arg2);
36114     } catch (std::out_of_range& e) {
36115       {
36116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36117       };
36118     } catch (std::exception& e) {
36119       {
36120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36121       };
36122     } catch (Dali::DaliException e) {
36123       {
36124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36125       };
36126     } catch (...) {
36127       {
36128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36129       };
36130     }
36131   }
36132
36133 }
36134
36135
36136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36137   unsigned int jresult ;
36138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36139   bool result;
36140
36141   arg1 = (Dali::Actor *)jarg1;
36142   {
36143     try {
36144       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36145     } catch (std::out_of_range& e) {
36146       {
36147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36148       };
36149     } catch (std::exception& e) {
36150       {
36151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36152       };
36153     } catch (Dali::DaliException e) {
36154       {
36155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36156       };
36157     } catch (...) {
36158       {
36159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36160       };
36161     }
36162   }
36163
36164   jresult = result;
36165   return jresult;
36166 }
36167
36168
36169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36170   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36171   bool arg2 ;
36172
36173   arg1 = (Dali::Actor *)jarg1;
36174   arg2 = jarg2 ? true : false;
36175   {
36176     try {
36177       (arg1)->SetKeyboardFocusable(arg2);
36178     } catch (std::out_of_range& e) {
36179       {
36180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36181       };
36182     } catch (std::exception& e) {
36183       {
36184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36185       };
36186     } catch (Dali::DaliException e) {
36187       {
36188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36189       };
36190     } catch (...) {
36191       {
36192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36193       };
36194     }
36195   }
36196
36197 }
36198
36199
36200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36201   unsigned int jresult ;
36202   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36203   bool result;
36204
36205   arg1 = (Dali::Actor *)jarg1;
36206   {
36207     try {
36208       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36209     } catch (std::out_of_range& e) {
36210       {
36211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36212       };
36213     } catch (std::exception& e) {
36214       {
36215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36216       };
36217     } catch (Dali::DaliException e) {
36218       {
36219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36220       };
36221     } catch (...) {
36222       {
36223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36224       };
36225     }
36226   }
36227
36228   jresult = result;
36229   return jresult;
36230 }
36231
36232
36233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36234   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36235   Dali::ResizePolicy::Type arg2 ;
36236   Dali::Dimension::Type arg3 ;
36237
36238   arg1 = (Dali::Actor *)jarg1;
36239   arg2 = (Dali::ResizePolicy::Type)jarg2;
36240   arg3 = (Dali::Dimension::Type)jarg3;
36241   {
36242     try {
36243       (arg1)->SetResizePolicy(arg2,arg3);
36244     } catch (std::out_of_range& e) {
36245       {
36246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36247       };
36248     } catch (std::exception& e) {
36249       {
36250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36251       };
36252     } catch (Dali::DaliException e) {
36253       {
36254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36255       };
36256     } catch (...) {
36257       {
36258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36259       };
36260     }
36261   }
36262
36263 }
36264
36265
36266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36267   int jresult ;
36268   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36269   Dali::Dimension::Type arg2 ;
36270   Dali::ResizePolicy::Type result;
36271
36272   arg1 = (Dali::Actor *)jarg1;
36273   arg2 = (Dali::Dimension::Type)jarg2;
36274   {
36275     try {
36276       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36277     } catch (std::out_of_range& e) {
36278       {
36279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36280       };
36281     } catch (std::exception& e) {
36282       {
36283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36284       };
36285     } catch (Dali::DaliException e) {
36286       {
36287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36288       };
36289     } catch (...) {
36290       {
36291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36292       };
36293     }
36294   }
36295
36296   jresult = (int)result;
36297   return jresult;
36298 }
36299
36300
36301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36302   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36303   Dali::SizeScalePolicy::Type arg2 ;
36304
36305   arg1 = (Dali::Actor *)jarg1;
36306   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36307   {
36308     try {
36309       (arg1)->SetSizeScalePolicy(arg2);
36310     } catch (std::out_of_range& e) {
36311       {
36312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36313       };
36314     } catch (std::exception& e) {
36315       {
36316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36317       };
36318     } catch (Dali::DaliException e) {
36319       {
36320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36321       };
36322     } catch (...) {
36323       {
36324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36325       };
36326     }
36327   }
36328
36329 }
36330
36331
36332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36333   int jresult ;
36334   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36335   Dali::SizeScalePolicy::Type result;
36336
36337   arg1 = (Dali::Actor *)jarg1;
36338   {
36339     try {
36340       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36341     } catch (std::out_of_range& e) {
36342       {
36343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36344       };
36345     } catch (std::exception& e) {
36346       {
36347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36348       };
36349     } catch (Dali::DaliException e) {
36350       {
36351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36352       };
36353     } catch (...) {
36354       {
36355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36356       };
36357     }
36358   }
36359
36360   jresult = (int)result;
36361   return jresult;
36362 }
36363
36364
36365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36367   Dali::Vector3 *arg2 = 0 ;
36368
36369   arg1 = (Dali::Actor *)jarg1;
36370   arg2 = (Dali::Vector3 *)jarg2;
36371   if (!arg2) {
36372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36373     return ;
36374   }
36375   {
36376     try {
36377       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36378     } catch (std::out_of_range& e) {
36379       {
36380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36381       };
36382     } catch (std::exception& e) {
36383       {
36384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36385       };
36386     } catch (Dali::DaliException e) {
36387       {
36388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36389       };
36390     } catch (...) {
36391       {
36392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36393       };
36394     }
36395   }
36396
36397 }
36398
36399
36400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36401   void * jresult ;
36402   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36403   Dali::Vector3 result;
36404
36405   arg1 = (Dali::Actor *)jarg1;
36406   {
36407     try {
36408       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36409     } catch (std::out_of_range& e) {
36410       {
36411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36412       };
36413     } catch (std::exception& e) {
36414       {
36415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36416       };
36417     } catch (Dali::DaliException e) {
36418       {
36419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36420       };
36421     } catch (...) {
36422       {
36423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36424       };
36425     }
36426   }
36427
36428   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36429   return jresult;
36430 }
36431
36432
36433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36434   float jresult ;
36435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36436   float arg2 ;
36437   float result;
36438
36439   arg1 = (Dali::Actor *)jarg1;
36440   arg2 = (float)jarg2;
36441   {
36442     try {
36443       result = (float)(arg1)->GetHeightForWidth(arg2);
36444     } catch (std::out_of_range& e) {
36445       {
36446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36447       };
36448     } catch (std::exception& e) {
36449       {
36450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36451       };
36452     } catch (Dali::DaliException e) {
36453       {
36454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36455       };
36456     } catch (...) {
36457       {
36458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36459       };
36460     }
36461   }
36462
36463   jresult = result;
36464   return jresult;
36465 }
36466
36467
36468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36469   float jresult ;
36470   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36471   float arg2 ;
36472   float result;
36473
36474   arg1 = (Dali::Actor *)jarg1;
36475   arg2 = (float)jarg2;
36476   {
36477     try {
36478       result = (float)(arg1)->GetWidthForHeight(arg2);
36479     } catch (std::out_of_range& e) {
36480       {
36481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36482       };
36483     } catch (std::exception& e) {
36484       {
36485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36486       };
36487     } catch (Dali::DaliException e) {
36488       {
36489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36490       };
36491     } catch (...) {
36492       {
36493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36494       };
36495     }
36496   }
36497
36498   jresult = result;
36499   return jresult;
36500 }
36501
36502
36503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36504   float jresult ;
36505   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36506   Dali::Dimension::Type arg2 ;
36507   float result;
36508
36509   arg1 = (Dali::Actor *)jarg1;
36510   arg2 = (Dali::Dimension::Type)jarg2;
36511   {
36512     try {
36513       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36514     } catch (std::out_of_range& e) {
36515       {
36516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36517       };
36518     } catch (std::exception& e) {
36519       {
36520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36521       };
36522     } catch (Dali::DaliException e) {
36523       {
36524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36525       };
36526     } catch (...) {
36527       {
36528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36529       };
36530     }
36531   }
36532
36533   jresult = result;
36534   return jresult;
36535 }
36536
36537
36538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36540   Dali::Padding *arg2 = 0 ;
36541
36542   arg1 = (Dali::Actor *)jarg1;
36543   arg2 = (Dali::Padding *)jarg2;
36544   if (!arg2) {
36545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36546     return ;
36547   }
36548   {
36549     try {
36550       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36551     } catch (std::out_of_range& e) {
36552       {
36553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36554       };
36555     } catch (std::exception& e) {
36556       {
36557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36558       };
36559     } catch (Dali::DaliException e) {
36560       {
36561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36562       };
36563     } catch (...) {
36564       {
36565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36566       };
36567     }
36568   }
36569
36570 }
36571
36572
36573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36574   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36575   Dali::Padding *arg2 = 0 ;
36576
36577   arg1 = (Dali::Actor *)jarg1;
36578   arg2 = (Dali::Padding *)jarg2;
36579   if (!arg2) {
36580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36581     return ;
36582   }
36583   {
36584     try {
36585       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36586     } catch (std::out_of_range& e) {
36587       {
36588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36589       };
36590     } catch (std::exception& e) {
36591       {
36592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36593       };
36594     } catch (Dali::DaliException e) {
36595       {
36596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36597       };
36598     } catch (...) {
36599       {
36600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36601       };
36602     }
36603   }
36604
36605 }
36606
36607
36608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36609   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36610   Dali::Vector2 *arg2 = 0 ;
36611
36612   arg1 = (Dali::Actor *)jarg1;
36613   arg2 = (Dali::Vector2 *)jarg2;
36614   if (!arg2) {
36615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36616     return ;
36617   }
36618   {
36619     try {
36620       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36621     } catch (std::out_of_range& e) {
36622       {
36623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36624       };
36625     } catch (std::exception& e) {
36626       {
36627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36628       };
36629     } catch (Dali::DaliException e) {
36630       {
36631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36632       };
36633     } catch (...) {
36634       {
36635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36636       };
36637     }
36638   }
36639
36640 }
36641
36642
36643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36644   void * jresult ;
36645   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36646   Dali::Vector2 result;
36647
36648   arg1 = (Dali::Actor *)jarg1;
36649   {
36650     try {
36651       result = (arg1)->GetMinimumSize();
36652     } catch (std::out_of_range& e) {
36653       {
36654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36655       };
36656     } catch (std::exception& e) {
36657       {
36658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36659       };
36660     } catch (Dali::DaliException e) {
36661       {
36662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36663       };
36664     } catch (...) {
36665       {
36666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36667       };
36668     }
36669   }
36670
36671   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36672   return jresult;
36673 }
36674
36675
36676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36677   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36678   Dali::Vector2 *arg2 = 0 ;
36679
36680   arg1 = (Dali::Actor *)jarg1;
36681   arg2 = (Dali::Vector2 *)jarg2;
36682   if (!arg2) {
36683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36684     return ;
36685   }
36686   {
36687     try {
36688       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36689     } catch (std::out_of_range& e) {
36690       {
36691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36692       };
36693     } catch (std::exception& e) {
36694       {
36695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36696       };
36697     } catch (Dali::DaliException e) {
36698       {
36699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36700       };
36701     } catch (...) {
36702       {
36703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36704       };
36705     }
36706   }
36707
36708 }
36709
36710
36711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36712   void * jresult ;
36713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36714   Dali::Vector2 result;
36715
36716   arg1 = (Dali::Actor *)jarg1;
36717   {
36718     try {
36719       result = (arg1)->GetMaximumSize();
36720     } catch (std::out_of_range& e) {
36721       {
36722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36723       };
36724     } catch (std::exception& e) {
36725       {
36726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36727       };
36728     } catch (Dali::DaliException e) {
36729       {
36730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36731       };
36732     } catch (...) {
36733       {
36734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36735       };
36736     }
36737   }
36738
36739   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36740   return jresult;
36741 }
36742
36743
36744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36745   int jresult ;
36746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36747   int result;
36748
36749   arg1 = (Dali::Actor *)jarg1;
36750   {
36751     try {
36752       result = (int)(arg1)->GetHierarchyDepth();
36753       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36754     } catch (std::out_of_range& e) {
36755       {
36756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36757       };
36758     } catch (std::exception& e) {
36759       {
36760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36761       };
36762     } catch (Dali::DaliException e) {
36763       {
36764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36765       };
36766     } catch (...) {
36767       {
36768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36769       };
36770     }
36771   }
36772
36773   jresult = result;
36774   return jresult;
36775 }
36776
36777
36778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36779   unsigned int jresult ;
36780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36781   Dali::Renderer *arg2 = 0 ;
36782   unsigned int result;
36783
36784   arg1 = (Dali::Actor *)jarg1;
36785   arg2 = (Dali::Renderer *)jarg2;
36786   if (!arg2) {
36787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36788     return 0;
36789   }
36790   {
36791     try {
36792       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36793     } catch (std::out_of_range& e) {
36794       {
36795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36796       };
36797     } catch (std::exception& e) {
36798       {
36799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36800       };
36801     } catch (Dali::DaliException e) {
36802       {
36803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36804       };
36805     } catch (...) {
36806       {
36807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36808       };
36809     }
36810   }
36811
36812   jresult = result;
36813   return jresult;
36814 }
36815
36816
36817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36818   unsigned int jresult ;
36819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36820   unsigned int result;
36821
36822   arg1 = (Dali::Actor *)jarg1;
36823   {
36824     try {
36825       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36826     } catch (std::out_of_range& e) {
36827       {
36828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36829       };
36830     } catch (std::exception& e) {
36831       {
36832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36833       };
36834     } catch (Dali::DaliException e) {
36835       {
36836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36837       };
36838     } catch (...) {
36839       {
36840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36841       };
36842     }
36843   }
36844
36845   jresult = result;
36846   return jresult;
36847 }
36848
36849
36850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36851   void * jresult ;
36852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36853   unsigned int arg2 ;
36854   Dali::Renderer result;
36855
36856   arg1 = (Dali::Actor *)jarg1;
36857   arg2 = (unsigned int)jarg2;
36858   {
36859     try {
36860       result = (arg1)->GetRendererAt(arg2);
36861     } catch (std::out_of_range& e) {
36862       {
36863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36864       };
36865     } catch (std::exception& e) {
36866       {
36867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36868       };
36869     } catch (Dali::DaliException e) {
36870       {
36871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36872       };
36873     } catch (...) {
36874       {
36875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36876       };
36877     }
36878   }
36879
36880   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36881   return jresult;
36882 }
36883
36884
36885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36887   Dali::Renderer *arg2 = 0 ;
36888
36889   arg1 = (Dali::Actor *)jarg1;
36890   arg2 = (Dali::Renderer *)jarg2;
36891   if (!arg2) {
36892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36893     return ;
36894   }
36895   {
36896     try {
36897       (arg1)->RemoveRenderer(*arg2);
36898     } catch (std::out_of_range& e) {
36899       {
36900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36901       };
36902     } catch (std::exception& e) {
36903       {
36904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36905       };
36906     } catch (Dali::DaliException e) {
36907       {
36908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36909       };
36910     } catch (...) {
36911       {
36912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36913       };
36914     }
36915   }
36916
36917 }
36918
36919
36920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36922   unsigned int arg2 ;
36923
36924   arg1 = (Dali::Actor *)jarg1;
36925   arg2 = (unsigned int)jarg2;
36926   {
36927     try {
36928       (arg1)->RemoveRenderer(arg2);
36929     } catch (std::out_of_range& e) {
36930       {
36931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36932       };
36933     } catch (std::exception& e) {
36934       {
36935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36936       };
36937     } catch (Dali::DaliException e) {
36938       {
36939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36940       };
36941     } catch (...) {
36942       {
36943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36944       };
36945     }
36946   }
36947
36948 }
36949
36950
36951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36952   void * jresult ;
36953   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36954   Dali::Actor::TouchSignalType *result = 0 ;
36955
36956   arg1 = (Dali::Actor *)jarg1;
36957   {
36958     try {
36959       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36960     } catch (std::out_of_range& e) {
36961       {
36962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36963       };
36964     } catch (std::exception& e) {
36965       {
36966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36967       };
36968     } catch (Dali::DaliException e) {
36969       {
36970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36971       };
36972     } catch (...) {
36973       {
36974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36975       };
36976     }
36977   }
36978
36979   jresult = (void *)result;
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36985   void * jresult ;
36986   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36987   Dali::Actor::TouchDataSignalType *result = 0 ;
36988
36989   arg1 = (Dali::Actor *)jarg1;
36990   {
36991     try {
36992       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36993     } catch (std::out_of_range& e) {
36994       {
36995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36996       };
36997     } catch (std::exception& e) {
36998       {
36999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37000       };
37001     } catch (Dali::DaliException e) {
37002       {
37003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37004       };
37005     } catch (...) {
37006       {
37007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37008       };
37009     }
37010   }
37011
37012   jresult = (void *)result;
37013   return jresult;
37014 }
37015
37016
37017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37018   void * jresult ;
37019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37020   Dali::Actor::HoverSignalType *result = 0 ;
37021
37022   arg1 = (Dali::Actor *)jarg1;
37023   {
37024     try {
37025       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37026     } catch (std::out_of_range& e) {
37027       {
37028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37029       };
37030     } catch (std::exception& e) {
37031       {
37032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37033       };
37034     } catch (Dali::DaliException e) {
37035       {
37036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37037       };
37038     } catch (...) {
37039       {
37040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37041       };
37042     }
37043   }
37044
37045   jresult = (void *)result;
37046   return jresult;
37047 }
37048
37049
37050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37051   void * jresult ;
37052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37053   Dali::Actor::WheelEventSignalType *result = 0 ;
37054
37055   arg1 = (Dali::Actor *)jarg1;
37056   {
37057     try {
37058       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37059     } catch (std::out_of_range& e) {
37060       {
37061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37062       };
37063     } catch (std::exception& e) {
37064       {
37065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37066       };
37067     } catch (Dali::DaliException e) {
37068       {
37069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37070       };
37071     } catch (...) {
37072       {
37073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37074       };
37075     }
37076   }
37077
37078   jresult = (void *)result;
37079   return jresult;
37080 }
37081
37082
37083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37084   void * jresult ;
37085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37086   Dali::Actor::OnStageSignalType *result = 0 ;
37087
37088   arg1 = (Dali::Actor *)jarg1;
37089   {
37090     try {
37091       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37092     } catch (std::out_of_range& e) {
37093       {
37094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37095       };
37096     } catch (std::exception& e) {
37097       {
37098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37099       };
37100     } catch (Dali::DaliException e) {
37101       {
37102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37103       };
37104     } catch (...) {
37105       {
37106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37107       };
37108     }
37109   }
37110
37111   jresult = (void *)result;
37112   return jresult;
37113 }
37114
37115
37116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37117   void * jresult ;
37118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37119   Dali::Actor::OffStageSignalType *result = 0 ;
37120
37121   arg1 = (Dali::Actor *)jarg1;
37122   {
37123     try {
37124       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37125     } catch (std::out_of_range& e) {
37126       {
37127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37128       };
37129     } catch (std::exception& e) {
37130       {
37131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37132       };
37133     } catch (Dali::DaliException e) {
37134       {
37135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37136       };
37137     } catch (...) {
37138       {
37139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37140       };
37141     }
37142   }
37143
37144   jresult = (void *)result;
37145   return jresult;
37146 }
37147
37148
37149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37150   void * jresult ;
37151   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37152   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37153
37154   arg1 = (Dali::Actor *)jarg1;
37155   {
37156     try {
37157       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37158     } catch (std::out_of_range& e) {
37159       {
37160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37161       };
37162     } catch (std::exception& e) {
37163       {
37164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37165       };
37166     } catch (Dali::DaliException e) {
37167       {
37168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37169       };
37170     } catch (...) {
37171       {
37172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37173       };
37174     }
37175   }
37176
37177   jresult = (void *)result;
37178   return jresult;
37179 }
37180
37181
37182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37183   Dali::Actor *arg1 = 0 ;
37184
37185   arg1 = (Dali::Actor *)jarg1;
37186   if (!arg1) {
37187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37188     return ;
37189   }
37190   {
37191     try {
37192       Dali::UnparentAndReset(*arg1);
37193     } catch (std::out_of_range& e) {
37194       {
37195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37196       };
37197     } catch (std::exception& e) {
37198       {
37199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37200       };
37201     } catch (Dali::DaliException e) {
37202       {
37203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37204       };
37205     } catch (...) {
37206       {
37207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37208       };
37209     }
37210   }
37211
37212 }
37213
37214
37215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37216   int jresult ;
37217   int result;
37218
37219   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37220   jresult = (int)result;
37221   return jresult;
37222 }
37223
37224
37225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37226   int jresult ;
37227   int result;
37228
37229   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37230   jresult = (int)result;
37231   return jresult;
37232 }
37233
37234
37235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37236   int jresult ;
37237   int result;
37238
37239   result = (int)Dali::Layer::Property::BEHAVIOR;
37240   jresult = (int)result;
37241   return jresult;
37242 }
37243
37244
37245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37246   void * jresult ;
37247   Dali::Layer::Property *result = 0 ;
37248
37249   {
37250     try {
37251       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37252     } catch (std::out_of_range& e) {
37253       {
37254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37255       };
37256     } catch (std::exception& e) {
37257       {
37258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37259       };
37260     } catch (Dali::DaliException e) {
37261       {
37262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37263       };
37264     } catch (...) {
37265       {
37266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37267       };
37268     }
37269   }
37270
37271   jresult = (void *)result;
37272   return jresult;
37273 }
37274
37275
37276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37277   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37278
37279   arg1 = (Dali::Layer::Property *)jarg1;
37280   {
37281     try {
37282       delete arg1;
37283     } catch (std::out_of_range& e) {
37284       {
37285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37286       };
37287     } catch (std::exception& e) {
37288       {
37289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37290       };
37291     } catch (Dali::DaliException e) {
37292       {
37293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37294       };
37295     } catch (...) {
37296       {
37297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37298       };
37299     }
37300   }
37301
37302 }
37303
37304
37305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37306   void * jresult ;
37307   Dali::Layer *result = 0 ;
37308
37309   {
37310     try {
37311       result = (Dali::Layer *)new Dali::Layer();
37312     } catch (std::out_of_range& e) {
37313       {
37314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37315       };
37316     } catch (std::exception& e) {
37317       {
37318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37319       };
37320     } catch (Dali::DaliException e) {
37321       {
37322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37323       };
37324     } catch (...) {
37325       {
37326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37327       };
37328     }
37329   }
37330
37331   jresult = (void *)result;
37332   return jresult;
37333 }
37334
37335
37336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37337   void * jresult ;
37338   Dali::Layer result;
37339
37340   {
37341     try {
37342       result = Dali::Layer::New();
37343     } catch (std::out_of_range& e) {
37344       {
37345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37346       };
37347     } catch (std::exception& e) {
37348       {
37349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37350       };
37351     } catch (Dali::DaliException e) {
37352       {
37353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37354       };
37355     } catch (...) {
37356       {
37357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37358       };
37359     }
37360   }
37361
37362   jresult = new Dali::Layer((const Dali::Layer &)result);
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37368   void * jresult ;
37369   Dali::BaseHandle arg1 ;
37370   Dali::BaseHandle *argp1 ;
37371   Dali::Layer result;
37372
37373   argp1 = (Dali::BaseHandle *)jarg1;
37374   if (!argp1) {
37375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37376     return 0;
37377   }
37378   arg1 = *argp1;
37379   {
37380     try {
37381       result = Dali::Layer::DownCast(arg1);
37382     } catch (std::out_of_range& e) {
37383       {
37384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37385       };
37386     } catch (std::exception& e) {
37387       {
37388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37389       };
37390     } catch (Dali::DaliException e) {
37391       {
37392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37393       };
37394     } catch (...) {
37395       {
37396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37397       };
37398     }
37399   }
37400
37401   jresult = new Dali::Layer((const Dali::Layer &)result);
37402   return jresult;
37403 }
37404
37405
37406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37407   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37408
37409   arg1 = (Dali::Layer *)jarg1;
37410   {
37411     try {
37412       delete arg1;
37413     } catch (std::out_of_range& e) {
37414       {
37415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37416       };
37417     } catch (std::exception& e) {
37418       {
37419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37420       };
37421     } catch (Dali::DaliException e) {
37422       {
37423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37424       };
37425     } catch (...) {
37426       {
37427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37428       };
37429     }
37430   }
37431
37432 }
37433
37434
37435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37436   void * jresult ;
37437   Dali::Layer *arg1 = 0 ;
37438   Dali::Layer *result = 0 ;
37439
37440   arg1 = (Dali::Layer *)jarg1;
37441   if (!arg1) {
37442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37443     return 0;
37444   }
37445   {
37446     try {
37447       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37448     } catch (std::out_of_range& e) {
37449       {
37450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37451       };
37452     } catch (std::exception& e) {
37453       {
37454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37455       };
37456     } catch (Dali::DaliException e) {
37457       {
37458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37459       };
37460     } catch (...) {
37461       {
37462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37463       };
37464     }
37465   }
37466
37467   jresult = (void *)result;
37468   return jresult;
37469 }
37470
37471
37472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37473   void * jresult ;
37474   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37475   Dali::Layer *arg2 = 0 ;
37476   Dali::Layer *result = 0 ;
37477
37478   arg1 = (Dali::Layer *)jarg1;
37479   arg2 = (Dali::Layer *)jarg2;
37480   if (!arg2) {
37481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37482     return 0;
37483   }
37484   {
37485     try {
37486       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37487     } catch (std::out_of_range& e) {
37488       {
37489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37490       };
37491     } catch (std::exception& e) {
37492       {
37493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37494       };
37495     } catch (Dali::DaliException e) {
37496       {
37497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37498       };
37499     } catch (...) {
37500       {
37501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37502       };
37503     }
37504   }
37505
37506   jresult = (void *)result;
37507   return jresult;
37508 }
37509
37510
37511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37512   unsigned int jresult ;
37513   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37514   unsigned int result;
37515
37516   arg1 = (Dali::Layer *)jarg1;
37517   {
37518     try {
37519       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37520     } catch (std::out_of_range& e) {
37521       {
37522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37523       };
37524     } catch (std::exception& e) {
37525       {
37526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37527       };
37528     } catch (Dali::DaliException e) {
37529       {
37530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37531       };
37532     } catch (...) {
37533       {
37534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37535       };
37536     }
37537   }
37538
37539   jresult = result;
37540   return jresult;
37541 }
37542
37543
37544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37545   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37546
37547   arg1 = (Dali::Layer *)jarg1;
37548   {
37549     try {
37550       (arg1)->Raise();
37551     } catch (std::out_of_range& e) {
37552       {
37553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37554       };
37555     } catch (std::exception& e) {
37556       {
37557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37558       };
37559     } catch (Dali::DaliException e) {
37560       {
37561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37562       };
37563     } catch (...) {
37564       {
37565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37566       };
37567     }
37568   }
37569
37570 }
37571
37572
37573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37574   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37575
37576   arg1 = (Dali::Layer *)jarg1;
37577   {
37578     try {
37579       (arg1)->Lower();
37580     } catch (std::out_of_range& e) {
37581       {
37582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37583       };
37584     } catch (std::exception& e) {
37585       {
37586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37587       };
37588     } catch (Dali::DaliException e) {
37589       {
37590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37591       };
37592     } catch (...) {
37593       {
37594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37595       };
37596     }
37597   }
37598
37599 }
37600
37601
37602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37603   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37604   Dali::Layer arg2 ;
37605   Dali::Layer *argp2 ;
37606
37607   arg1 = (Dali::Layer *)jarg1;
37608   argp2 = (Dali::Layer *)jarg2;
37609   if (!argp2) {
37610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37611     return ;
37612   }
37613   arg2 = *argp2;
37614   {
37615     try {
37616       (arg1)->RaiseAbove(arg2);
37617     } catch (std::out_of_range& e) {
37618       {
37619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37620       };
37621     } catch (std::exception& e) {
37622       {
37623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37624       };
37625     } catch (Dali::DaliException e) {
37626       {
37627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37628       };
37629     } catch (...) {
37630       {
37631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37632       };
37633     }
37634   }
37635
37636 }
37637
37638
37639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37640   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37641   Dali::Layer arg2 ;
37642   Dali::Layer *argp2 ;
37643
37644   arg1 = (Dali::Layer *)jarg1;
37645   argp2 = (Dali::Layer *)jarg2;
37646   if (!argp2) {
37647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37648     return ;
37649   }
37650   arg2 = *argp2;
37651   {
37652     try {
37653       (arg1)->LowerBelow(arg2);
37654     } catch (std::out_of_range& e) {
37655       {
37656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37657       };
37658     } catch (std::exception& e) {
37659       {
37660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37661       };
37662     } catch (Dali::DaliException e) {
37663       {
37664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37665       };
37666     } catch (...) {
37667       {
37668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37669       };
37670     }
37671   }
37672
37673 }
37674
37675
37676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37677   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37678
37679   arg1 = (Dali::Layer *)jarg1;
37680   {
37681     try {
37682       (arg1)->RaiseToTop();
37683     } catch (std::out_of_range& e) {
37684       {
37685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37686       };
37687     } catch (std::exception& e) {
37688       {
37689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37690       };
37691     } catch (Dali::DaliException e) {
37692       {
37693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37694       };
37695     } catch (...) {
37696       {
37697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37698       };
37699     }
37700   }
37701
37702 }
37703
37704
37705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37706   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37707
37708   arg1 = (Dali::Layer *)jarg1;
37709   {
37710     try {
37711       (arg1)->LowerToBottom();
37712     } catch (std::out_of_range& e) {
37713       {
37714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37715       };
37716     } catch (std::exception& e) {
37717       {
37718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37719       };
37720     } catch (Dali::DaliException e) {
37721       {
37722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37723       };
37724     } catch (...) {
37725       {
37726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37727       };
37728     }
37729   }
37730
37731 }
37732
37733
37734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37735   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37736   Dali::Layer arg2 ;
37737   Dali::Layer *argp2 ;
37738
37739   arg1 = (Dali::Layer *)jarg1;
37740   argp2 = (Dali::Layer *)jarg2;
37741   if (!argp2) {
37742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37743     return ;
37744   }
37745   arg2 = *argp2;
37746   {
37747     try {
37748       (arg1)->MoveAbove(arg2);
37749     } catch (std::out_of_range& e) {
37750       {
37751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37752       };
37753     } catch (std::exception& e) {
37754       {
37755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37756       };
37757     } catch (Dali::DaliException e) {
37758       {
37759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37760       };
37761     } catch (...) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37764       };
37765     }
37766   }
37767
37768 }
37769
37770
37771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37772   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37773   Dali::Layer arg2 ;
37774   Dali::Layer *argp2 ;
37775
37776   arg1 = (Dali::Layer *)jarg1;
37777   argp2 = (Dali::Layer *)jarg2;
37778   if (!argp2) {
37779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37780     return ;
37781   }
37782   arg2 = *argp2;
37783   {
37784     try {
37785       (arg1)->MoveBelow(arg2);
37786     } catch (std::out_of_range& e) {
37787       {
37788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37789       };
37790     } catch (std::exception& e) {
37791       {
37792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37793       };
37794     } catch (Dali::DaliException e) {
37795       {
37796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37797       };
37798     } catch (...) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37801       };
37802     }
37803   }
37804
37805 }
37806
37807
37808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37809   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37810   Dali::Layer::Behavior arg2 ;
37811
37812   arg1 = (Dali::Layer *)jarg1;
37813   arg2 = (Dali::Layer::Behavior)jarg2;
37814   {
37815     try {
37816       (arg1)->SetBehavior(arg2);
37817     } catch (std::out_of_range& e) {
37818       {
37819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37820       };
37821     } catch (std::exception& e) {
37822       {
37823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37824       };
37825     } catch (Dali::DaliException e) {
37826       {
37827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37828       };
37829     } catch (...) {
37830       {
37831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37832       };
37833     }
37834   }
37835
37836 }
37837
37838
37839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37840   int jresult ;
37841   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37842   Dali::Layer::Behavior result;
37843
37844   arg1 = (Dali::Layer *)jarg1;
37845   {
37846     try {
37847       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37848     } catch (std::out_of_range& e) {
37849       {
37850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37851       };
37852     } catch (std::exception& e) {
37853       {
37854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37855       };
37856     } catch (Dali::DaliException e) {
37857       {
37858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37859       };
37860     } catch (...) {
37861       {
37862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37863       };
37864     }
37865   }
37866
37867   jresult = (int)result;
37868   return jresult;
37869 }
37870
37871
37872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37873   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37874   bool arg2 ;
37875
37876   arg1 = (Dali::Layer *)jarg1;
37877   arg2 = jarg2 ? true : false;
37878   {
37879     try {
37880       (arg1)->SetClipping(arg2);
37881     } catch (std::out_of_range& e) {
37882       {
37883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37884       };
37885     } catch (std::exception& e) {
37886       {
37887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37888       };
37889     } catch (Dali::DaliException e) {
37890       {
37891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37892       };
37893     } catch (...) {
37894       {
37895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37896       };
37897     }
37898   }
37899
37900 }
37901
37902
37903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37904   unsigned int jresult ;
37905   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37906   bool result;
37907
37908   arg1 = (Dali::Layer *)jarg1;
37909   {
37910     try {
37911       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37912     } catch (std::out_of_range& e) {
37913       {
37914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37915       };
37916     } catch (std::exception& e) {
37917       {
37918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37919       };
37920     } catch (Dali::DaliException e) {
37921       {
37922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37923       };
37924     } catch (...) {
37925       {
37926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37927       };
37928     }
37929   }
37930
37931   jresult = result;
37932   return jresult;
37933 }
37934
37935
37936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37937   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37938   int arg2 ;
37939   int arg3 ;
37940   int arg4 ;
37941   int arg5 ;
37942
37943   arg1 = (Dali::Layer *)jarg1;
37944   arg2 = (int)jarg2;
37945   arg3 = (int)jarg3;
37946   arg4 = (int)jarg4;
37947   arg5 = (int)jarg5;
37948   {
37949     try {
37950       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37951     } catch (std::out_of_range& e) {
37952       {
37953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37954       };
37955     } catch (std::exception& e) {
37956       {
37957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37958       };
37959     } catch (Dali::DaliException e) {
37960       {
37961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37962       };
37963     } catch (...) {
37964       {
37965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37966       };
37967     }
37968   }
37969
37970 }
37971
37972
37973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37974   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37975   Dali::ClippingBox arg2 ;
37976   Dali::ClippingBox *argp2 ;
37977
37978   arg1 = (Dali::Layer *)jarg1;
37979   argp2 = (Dali::ClippingBox *)jarg2;
37980   if (!argp2) {
37981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37982     return ;
37983   }
37984   arg2 = *argp2;
37985   {
37986     try {
37987       (arg1)->SetClippingBox(arg2);
37988     } catch (std::out_of_range& e) {
37989       {
37990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37991       };
37992     } catch (std::exception& e) {
37993       {
37994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37995       };
37996     } catch (Dali::DaliException e) {
37997       {
37998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37999       };
38000     } catch (...) {
38001       {
38002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38003       };
38004     }
38005   }
38006
38007 }
38008
38009
38010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38011   void * jresult ;
38012   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38013   Dali::ClippingBox result;
38014
38015   arg1 = (Dali::Layer *)jarg1;
38016   {
38017     try {
38018       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38019     } catch (std::out_of_range& e) {
38020       {
38021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38022       };
38023     } catch (std::exception& e) {
38024       {
38025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38026       };
38027     } catch (Dali::DaliException e) {
38028       {
38029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38030       };
38031     } catch (...) {
38032       {
38033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38034       };
38035     }
38036   }
38037
38038   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38039   return jresult;
38040 }
38041
38042
38043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38044   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38045   bool arg2 ;
38046
38047   arg1 = (Dali::Layer *)jarg1;
38048   arg2 = jarg2 ? true : false;
38049   {
38050     try {
38051       (arg1)->SetDepthTestDisabled(arg2);
38052     } catch (std::out_of_range& e) {
38053       {
38054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38055       };
38056     } catch (std::exception& e) {
38057       {
38058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38059       };
38060     } catch (Dali::DaliException e) {
38061       {
38062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38063       };
38064     } catch (...) {
38065       {
38066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38067       };
38068     }
38069   }
38070
38071 }
38072
38073
38074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38075   unsigned int jresult ;
38076   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38077   bool result;
38078
38079   arg1 = (Dali::Layer *)jarg1;
38080   {
38081     try {
38082       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38083     } catch (std::out_of_range& e) {
38084       {
38085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38086       };
38087     } catch (std::exception& e) {
38088       {
38089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (Dali::DaliException e) {
38092       {
38093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38094       };
38095     } catch (...) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38098       };
38099     }
38100   }
38101
38102   jresult = result;
38103   return jresult;
38104 }
38105
38106
38107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38108   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38109   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38110
38111   arg1 = (Dali::Layer *)jarg1;
38112   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38113   {
38114     try {
38115       (arg1)->SetSortFunction(arg2);
38116     } catch (std::out_of_range& e) {
38117       {
38118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38119       };
38120     } catch (std::exception& e) {
38121       {
38122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38123       };
38124     } catch (Dali::DaliException e) {
38125       {
38126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38127       };
38128     } catch (...) {
38129       {
38130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38131       };
38132     }
38133   }
38134
38135 }
38136
38137
38138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38139   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38140   bool arg2 ;
38141
38142   arg1 = (Dali::Layer *)jarg1;
38143   arg2 = jarg2 ? true : false;
38144   {
38145     try {
38146       (arg1)->SetTouchConsumed(arg2);
38147     } catch (std::out_of_range& e) {
38148       {
38149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38150       };
38151     } catch (std::exception& e) {
38152       {
38153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38154       };
38155     } catch (Dali::DaliException e) {
38156       {
38157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38158       };
38159     } catch (...) {
38160       {
38161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38162       };
38163     }
38164   }
38165
38166 }
38167
38168
38169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38170   unsigned int jresult ;
38171   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38172   bool result;
38173
38174   arg1 = (Dali::Layer *)jarg1;
38175   {
38176     try {
38177       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38178     } catch (std::out_of_range& e) {
38179       {
38180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38181       };
38182     } catch (std::exception& e) {
38183       {
38184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38185       };
38186     } catch (Dali::DaliException e) {
38187       {
38188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38189       };
38190     } catch (...) {
38191       {
38192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38193       };
38194     }
38195   }
38196
38197   jresult = result;
38198   return jresult;
38199 }
38200
38201
38202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38203   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38204   bool arg2 ;
38205
38206   arg1 = (Dali::Layer *)jarg1;
38207   arg2 = jarg2 ? true : false;
38208   {
38209     try {
38210       (arg1)->SetHoverConsumed(arg2);
38211     } catch (std::out_of_range& e) {
38212       {
38213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38214       };
38215     } catch (std::exception& e) {
38216       {
38217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38218       };
38219     } catch (Dali::DaliException e) {
38220       {
38221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38222       };
38223     } catch (...) {
38224       {
38225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38226       };
38227     }
38228   }
38229
38230 }
38231
38232
38233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38234   unsigned int jresult ;
38235   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38236   bool result;
38237
38238   arg1 = (Dali::Layer *)jarg1;
38239   {
38240     try {
38241       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38242     } catch (std::out_of_range& e) {
38243       {
38244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38245       };
38246     } catch (std::exception& e) {
38247       {
38248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38249       };
38250     } catch (Dali::DaliException e) {
38251       {
38252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38253       };
38254     } catch (...) {
38255       {
38256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38257       };
38258     }
38259   }
38260
38261   jresult = result;
38262   return jresult;
38263 }
38264
38265
38266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38267   void * jresult ;
38268   Dali::Vector4 *result = 0 ;
38269
38270   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38271   jresult = (void *)result;
38272   return jresult;
38273 }
38274
38275
38276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38277   void * jresult ;
38278   Dali::Vector4 *result = 0 ;
38279
38280   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38281   jresult = (void *)result;
38282   return jresult;
38283 }
38284
38285
38286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38287   void * jresult ;
38288   Dali::Stage *result = 0 ;
38289
38290   {
38291     try {
38292       result = (Dali::Stage *)new Dali::Stage();
38293     } catch (std::out_of_range& e) {
38294       {
38295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38296       };
38297     } catch (std::exception& e) {
38298       {
38299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38300       };
38301     } catch (Dali::DaliException e) {
38302       {
38303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38304       };
38305     } catch (...) {
38306       {
38307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38308       };
38309     }
38310   }
38311
38312   jresult = (void *)result;
38313   return jresult;
38314 }
38315
38316
38317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38318   void * jresult ;
38319   Dali::Stage result;
38320
38321   {
38322     try {
38323       result = Dali::Stage::GetCurrent();
38324     } catch (std::out_of_range& e) {
38325       {
38326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38327       };
38328     } catch (std::exception& e) {
38329       {
38330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38331       };
38332     } catch (Dali::DaliException e) {
38333       {
38334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38335       };
38336     } catch (...) {
38337       {
38338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38339       };
38340     }
38341   }
38342
38343   jresult = new Dali::Stage((const Dali::Stage &)result);
38344   return jresult;
38345 }
38346
38347
38348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38349   unsigned int jresult ;
38350   bool result;
38351
38352   {
38353     try {
38354       result = (bool)Dali::Stage::IsInstalled();
38355     } catch (std::out_of_range& e) {
38356       {
38357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38358       };
38359     } catch (std::exception& e) {
38360       {
38361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38362       };
38363     } catch (Dali::DaliException e) {
38364       {
38365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38366       };
38367     } catch (...) {
38368       {
38369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38370       };
38371     }
38372   }
38373
38374   jresult = result;
38375   return jresult;
38376 }
38377
38378
38379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38380   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38381
38382   arg1 = (Dali::Stage *)jarg1;
38383   {
38384     try {
38385       delete arg1;
38386     } catch (std::out_of_range& e) {
38387       {
38388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38389       };
38390     } catch (std::exception& e) {
38391       {
38392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38393       };
38394     } catch (Dali::DaliException e) {
38395       {
38396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38397       };
38398     } catch (...) {
38399       {
38400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38401       };
38402     }
38403   }
38404
38405 }
38406
38407
38408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38409   void * jresult ;
38410   Dali::Stage *arg1 = 0 ;
38411   Dali::Stage *result = 0 ;
38412
38413   arg1 = (Dali::Stage *)jarg1;
38414   if (!arg1) {
38415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38416     return 0;
38417   }
38418   {
38419     try {
38420       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38421     } catch (std::out_of_range& e) {
38422       {
38423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (std::exception& e) {
38426       {
38427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38428       };
38429     } catch (Dali::DaliException e) {
38430       {
38431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38432       };
38433     } catch (...) {
38434       {
38435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38436       };
38437     }
38438   }
38439
38440   jresult = (void *)result;
38441   return jresult;
38442 }
38443
38444
38445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38446   void * jresult ;
38447   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38448   Dali::Stage *arg2 = 0 ;
38449   Dali::Stage *result = 0 ;
38450
38451   arg1 = (Dali::Stage *)jarg1;
38452   arg2 = (Dali::Stage *)jarg2;
38453   if (!arg2) {
38454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38455     return 0;
38456   }
38457   {
38458     try {
38459       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38460     } catch (std::out_of_range& e) {
38461       {
38462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38463       };
38464     } catch (std::exception& e) {
38465       {
38466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38467       };
38468     } catch (Dali::DaliException e) {
38469       {
38470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38471       };
38472     } catch (...) {
38473       {
38474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38475       };
38476     }
38477   }
38478
38479   jresult = (void *)result;
38480   return jresult;
38481 }
38482
38483
38484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38485   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38486   Dali::Actor *arg2 = 0 ;
38487
38488   arg1 = (Dali::Stage *)jarg1;
38489   arg2 = (Dali::Actor *)jarg2;
38490   if (!arg2) {
38491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38492     return ;
38493   }
38494   {
38495     try {
38496       (arg1)->Add(*arg2);
38497     } catch (std::out_of_range& e) {
38498       {
38499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38500       };
38501     } catch (std::exception& e) {
38502       {
38503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38504       };
38505     } catch (Dali::DaliException e) {
38506       {
38507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38508       };
38509     } catch (...) {
38510       {
38511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38512       };
38513     }
38514   }
38515
38516 }
38517
38518
38519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38520   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38521   Dali::Actor *arg2 = 0 ;
38522
38523   arg1 = (Dali::Stage *)jarg1;
38524   arg2 = (Dali::Actor *)jarg2;
38525   if (!arg2) {
38526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38527     return ;
38528   }
38529   {
38530     try {
38531       (arg1)->Remove(*arg2);
38532     } catch (std::out_of_range& e) {
38533       {
38534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38535       };
38536     } catch (std::exception& e) {
38537       {
38538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38539       };
38540     } catch (Dali::DaliException e) {
38541       {
38542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38543       };
38544     } catch (...) {
38545       {
38546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38547       };
38548     }
38549   }
38550
38551 }
38552
38553
38554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38555   void * jresult ;
38556   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38557   Dali::Vector2 result;
38558
38559   arg1 = (Dali::Stage *)jarg1;
38560   {
38561     try {
38562       result = ((Dali::Stage const *)arg1)->GetSize();
38563     } catch (std::out_of_range& e) {
38564       {
38565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38566       };
38567     } catch (std::exception& e) {
38568       {
38569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38570       };
38571     } catch (Dali::DaliException e) {
38572       {
38573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38574       };
38575     } catch (...) {
38576       {
38577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38578       };
38579     }
38580   }
38581
38582   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38583   return jresult;
38584 }
38585
38586
38587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38588   void * jresult ;
38589   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38590   Dali::RenderTaskList result;
38591
38592   arg1 = (Dali::Stage *)jarg1;
38593   {
38594     try {
38595       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38596     } catch (std::out_of_range& e) {
38597       {
38598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38599       };
38600     } catch (std::exception& e) {
38601       {
38602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38603       };
38604     } catch (Dali::DaliException e) {
38605       {
38606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38607       };
38608     } catch (...) {
38609       {
38610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38611       };
38612     }
38613   }
38614
38615   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38616   return jresult;
38617 }
38618
38619
38620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38621   unsigned int jresult ;
38622   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38623   unsigned int result;
38624
38625   arg1 = (Dali::Stage *)jarg1;
38626   {
38627     try {
38628       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38629     } catch (std::out_of_range& e) {
38630       {
38631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38632       };
38633     } catch (std::exception& e) {
38634       {
38635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38636       };
38637     } catch (Dali::DaliException e) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38640       };
38641     } catch (...) {
38642       {
38643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38644       };
38645     }
38646   }
38647
38648   jresult = result;
38649   return jresult;
38650 }
38651
38652
38653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38654   void * jresult ;
38655   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38656   unsigned int arg2 ;
38657   Dali::Layer result;
38658
38659   arg1 = (Dali::Stage *)jarg1;
38660   arg2 = (unsigned int)jarg2;
38661   {
38662     try {
38663       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38664     } catch (std::out_of_range& e) {
38665       {
38666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38667       };
38668     } catch (std::exception& e) {
38669       {
38670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38671       };
38672     } catch (Dali::DaliException e) {
38673       {
38674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38675       };
38676     } catch (...) {
38677       {
38678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38679       };
38680     }
38681   }
38682
38683   jresult = new Dali::Layer((const Dali::Layer &)result);
38684   return jresult;
38685 }
38686
38687
38688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38689   void * jresult ;
38690   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38691   Dali::Layer result;
38692
38693   arg1 = (Dali::Stage *)jarg1;
38694   {
38695     try {
38696       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38697     } catch (std::out_of_range& e) {
38698       {
38699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38700       };
38701     } catch (std::exception& e) {
38702       {
38703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38704       };
38705     } catch (Dali::DaliException e) {
38706       {
38707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38708       };
38709     } catch (...) {
38710       {
38711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38712       };
38713     }
38714   }
38715
38716   jresult = new Dali::Layer((const Dali::Layer &)result);
38717   return jresult;
38718 }
38719
38720
38721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38722   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38723   Dali::Vector4 arg2 ;
38724   Dali::Vector4 *argp2 ;
38725
38726   arg1 = (Dali::Stage *)jarg1;
38727   argp2 = (Dali::Vector4 *)jarg2;
38728   if (!argp2) {
38729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38730     return ;
38731   }
38732   arg2 = *argp2;
38733   {
38734     try {
38735       (arg1)->SetBackgroundColor(arg2);
38736     } catch (std::out_of_range& e) {
38737       {
38738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38739       };
38740     } catch (std::exception& e) {
38741       {
38742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38743       };
38744     } catch (Dali::DaliException e) {
38745       {
38746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38747       };
38748     } catch (...) {
38749       {
38750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38751       };
38752     }
38753   }
38754
38755 }
38756
38757
38758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38759   void * jresult ;
38760   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38761   Dali::Vector4 result;
38762
38763   arg1 = (Dali::Stage *)jarg1;
38764   {
38765     try {
38766       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38767     } catch (std::out_of_range& e) {
38768       {
38769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38770       };
38771     } catch (std::exception& e) {
38772       {
38773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38774       };
38775     } catch (Dali::DaliException e) {
38776       {
38777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38778       };
38779     } catch (...) {
38780       {
38781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38782       };
38783     }
38784   }
38785
38786   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38787   return jresult;
38788 }
38789
38790
38791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38792   void * jresult ;
38793   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38794   Dali::Vector2 result;
38795
38796   arg1 = (Dali::Stage *)jarg1;
38797   {
38798     try {
38799       result = ((Dali::Stage const *)arg1)->GetDpi();
38800     } catch (std::out_of_range& e) {
38801       {
38802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38803       };
38804     } catch (std::exception& e) {
38805       {
38806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38807       };
38808     } catch (Dali::DaliException e) {
38809       {
38810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38811       };
38812     } catch (...) {
38813       {
38814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38815       };
38816     }
38817   }
38818
38819   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38820   return jresult;
38821 }
38822
38823
38824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38825   void * jresult ;
38826   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38827   Dali::ObjectRegistry result;
38828
38829   arg1 = (Dali::Stage *)jarg1;
38830   {
38831     try {
38832       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38833     } catch (std::out_of_range& e) {
38834       {
38835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38836       };
38837     } catch (std::exception& e) {
38838       {
38839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38840       };
38841     } catch (Dali::DaliException e) {
38842       {
38843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38844       };
38845     } catch (...) {
38846       {
38847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38848       };
38849     }
38850   }
38851
38852   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38853   return jresult;
38854 }
38855
38856
38857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38858   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38859   float arg2 ;
38860
38861   arg1 = (Dali::Stage *)jarg1;
38862   arg2 = (float)jarg2;
38863   {
38864     try {
38865       (arg1)->KeepRendering(arg2);
38866     } catch (std::out_of_range& e) {
38867       {
38868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38869       };
38870     } catch (std::exception& e) {
38871       {
38872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38873       };
38874     } catch (Dali::DaliException e) {
38875       {
38876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38877       };
38878     } catch (...) {
38879       {
38880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38881       };
38882     }
38883   }
38884
38885 }
38886
38887
38888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38889   void * jresult ;
38890   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38891   Dali::Stage::KeyEventSignalType *result = 0 ;
38892
38893   arg1 = (Dali::Stage *)jarg1;
38894   {
38895     try {
38896       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38897     } catch (std::out_of_range& e) {
38898       {
38899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38900       };
38901     } catch (std::exception& e) {
38902       {
38903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38904       };
38905     } catch (Dali::DaliException e) {
38906       {
38907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38908       };
38909     } catch (...) {
38910       {
38911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38912       };
38913     }
38914   }
38915
38916   jresult = (void *)result;
38917   return jresult;
38918 }
38919
38920
38921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38922   void * jresult ;
38923   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38924   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38925
38926   arg1 = (Dali::Stage *)jarg1;
38927   {
38928     try {
38929       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38930     } catch (std::out_of_range& e) {
38931       {
38932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38933       };
38934     } catch (std::exception& e) {
38935       {
38936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38937       };
38938     } catch (Dali::DaliException e) {
38939       {
38940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38941       };
38942     } catch (...) {
38943       {
38944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38945       };
38946     }
38947   }
38948
38949   jresult = (void *)result;
38950   return jresult;
38951 }
38952
38953
38954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38955   void * jresult ;
38956   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38957   Dali::Stage::TouchSignalType *result = 0 ;
38958
38959   arg1 = (Dali::Stage *)jarg1;
38960   {
38961     try {
38962       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38963     } catch (std::out_of_range& e) {
38964       {
38965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38966       };
38967     } catch (std::exception& e) {
38968       {
38969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38970       };
38971     } catch (Dali::DaliException e) {
38972       {
38973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38974       };
38975     } catch (...) {
38976       {
38977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38978       };
38979     }
38980   }
38981
38982   jresult = (void *)result;
38983   return jresult;
38984 }
38985
38986
38987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38988   void * jresult ;
38989   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38990   Dali::Stage::WheelEventSignalType *result = 0 ;
38991
38992   arg1 = (Dali::Stage *)jarg1;
38993   {
38994     try {
38995       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38996     } catch (std::out_of_range& e) {
38997       {
38998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38999       };
39000     } catch (std::exception& e) {
39001       {
39002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39003       };
39004     } catch (Dali::DaliException e) {
39005       {
39006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39007       };
39008     } catch (...) {
39009       {
39010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39011       };
39012     }
39013   }
39014
39015   jresult = (void *)result;
39016   return jresult;
39017 }
39018
39019
39020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39021   void * jresult ;
39022   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39023   Dali::Stage::ContextStatusSignal *result = 0 ;
39024
39025   arg1 = (Dali::Stage *)jarg1;
39026   {
39027     try {
39028       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39029     } catch (std::out_of_range& e) {
39030       {
39031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39032       };
39033     } catch (std::exception& e) {
39034       {
39035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39036       };
39037     } catch (Dali::DaliException e) {
39038       {
39039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39040       };
39041     } catch (...) {
39042       {
39043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39044       };
39045     }
39046   }
39047
39048   jresult = (void *)result;
39049   return jresult;
39050 }
39051
39052
39053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39054   void * jresult ;
39055   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39056   Dali::Stage::ContextStatusSignal *result = 0 ;
39057
39058   arg1 = (Dali::Stage *)jarg1;
39059   {
39060     try {
39061       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39062     } catch (std::out_of_range& e) {
39063       {
39064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39065       };
39066     } catch (std::exception& e) {
39067       {
39068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39069       };
39070     } catch (Dali::DaliException e) {
39071       {
39072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39073       };
39074     } catch (...) {
39075       {
39076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39077       };
39078     }
39079   }
39080
39081   jresult = (void *)result;
39082   return jresult;
39083 }
39084
39085
39086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39087   void * jresult ;
39088   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39089   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39090
39091   arg1 = (Dali::Stage *)jarg1;
39092   {
39093     try {
39094       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39095     } catch (std::out_of_range& e) {
39096       {
39097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39098       };
39099     } catch (std::exception& e) {
39100       {
39101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39102       };
39103     } catch (Dali::DaliException e) {
39104       {
39105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39106       };
39107     } catch (...) {
39108       {
39109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39110       };
39111     }
39112   }
39113
39114   jresult = (void *)result;
39115   return jresult;
39116 }
39117
39118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39119   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39120   Dali::DevelStage::Rendering arg2 ;
39121
39122   arg1 = (Dali::Stage *)jarg1;
39123   arg2 = (Dali::DevelStage::Rendering)jarg2;
39124   {
39125     try {
39126       DevelStage::SetRenderingBehavior(*arg1,arg2);
39127     } catch (std::out_of_range& e) {
39128       {
39129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39130       };
39131     } catch (std::exception& e) {
39132       {
39133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39134       };
39135     } catch (Dali::DaliException e) {
39136       {
39137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39138       };
39139     } catch (...) {
39140       {
39141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39142       };
39143     }
39144   }
39145
39146 }
39147
39148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39149
39150   int jresult ;
39151   int result ;
39152   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39153
39154   arg1 = (Dali::Stage *)jarg1;
39155   {
39156     try {
39157       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39158     } catch (std::out_of_range& e) {
39159       {
39160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39161       };
39162     } catch (std::exception& e) {
39163       {
39164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39165       };
39166     } catch (Dali::DaliException e) {
39167       {
39168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39169       };
39170     } catch (...) {
39171       {
39172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39173       };
39174     }
39175   }
39176
39177   jresult = result;
39178   return jresult;
39179 }
39180
39181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39182   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39183
39184   arg1 = (Dali::RelayoutContainer *)jarg1;
39185   {
39186     try {
39187       delete arg1;
39188     } catch (std::out_of_range& e) {
39189       {
39190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39191       };
39192     } catch (std::exception& e) {
39193       {
39194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39195       };
39196     } catch (Dali::DaliException e) {
39197       {
39198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39199       };
39200     } catch (...) {
39201       {
39202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39203       };
39204     }
39205   }
39206
39207 }
39208
39209
39210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39211   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39212   Dali::Actor *arg2 = 0 ;
39213   Dali::Vector2 *arg3 = 0 ;
39214
39215   arg1 = (Dali::RelayoutContainer *)jarg1;
39216   arg2 = (Dali::Actor *)jarg2;
39217   if (!arg2) {
39218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39219     return ;
39220   }
39221   arg3 = (Dali::Vector2 *)jarg3;
39222   if (!arg3) {
39223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39224     return ;
39225   }
39226   {
39227     try {
39228       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39229     } catch (std::out_of_range& e) {
39230       {
39231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39232       };
39233     } catch (std::exception& e) {
39234       {
39235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39236       };
39237     } catch (Dali::DaliException e) {
39238       {
39239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39240       };
39241     } catch (...) {
39242       {
39243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39244       };
39245     }
39246   }
39247
39248 }
39249
39250
39251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39252   void * jresult ;
39253   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39254   Dali::CustomActor result;
39255
39256   arg1 = (Dali::CustomActorImpl *)jarg1;
39257   {
39258     try {
39259       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39260     } catch (std::out_of_range& e) {
39261       {
39262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39263       };
39264     } catch (std::exception& e) {
39265       {
39266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39267       };
39268     } catch (Dali::DaliException e) {
39269       {
39270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39271       };
39272     } catch (...) {
39273       {
39274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39275       };
39276     }
39277   }
39278
39279   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39280   return jresult;
39281 }
39282
39283
39284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39285   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39286   int arg2 ;
39287
39288   arg1 = (Dali::CustomActorImpl *)jarg1;
39289   arg2 = (int)jarg2;
39290   {
39291     try {
39292       (arg1)->OnStageConnection(arg2);
39293     } catch (std::out_of_range& e) {
39294       {
39295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39296       };
39297     } catch (std::exception& e) {
39298       {
39299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39300       };
39301     } catch (Dali::DaliException e) {
39302       {
39303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39304       };
39305     } catch (...) {
39306       {
39307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39308       };
39309     }
39310   }
39311
39312 }
39313
39314
39315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39316   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39317
39318   arg1 = (Dali::CustomActorImpl *)jarg1;
39319   {
39320     try {
39321       (arg1)->OnStageDisconnection();
39322     } catch (std::out_of_range& e) {
39323       {
39324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39325       };
39326     } catch (std::exception& e) {
39327       {
39328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39329       };
39330     } catch (Dali::DaliException e) {
39331       {
39332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39333       };
39334     } catch (...) {
39335       {
39336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39337       };
39338     }
39339   }
39340
39341 }
39342
39343
39344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39345   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39346   Dali::Actor *arg2 = 0 ;
39347
39348   arg1 = (Dali::CustomActorImpl *)jarg1;
39349   arg2 = (Dali::Actor *)jarg2;
39350   if (!arg2) {
39351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39352     return ;
39353   }
39354   {
39355     try {
39356       (arg1)->OnChildAdd(*arg2);
39357     } catch (std::out_of_range& e) {
39358       {
39359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39360       };
39361     } catch (std::exception& e) {
39362       {
39363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39364       };
39365     } catch (Dali::DaliException e) {
39366       {
39367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39368       };
39369     } catch (...) {
39370       {
39371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39372       };
39373     }
39374   }
39375
39376 }
39377
39378
39379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39380   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39381   Dali::Actor *arg2 = 0 ;
39382
39383   arg1 = (Dali::CustomActorImpl *)jarg1;
39384   arg2 = (Dali::Actor *)jarg2;
39385   if (!arg2) {
39386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39387     return ;
39388   }
39389   {
39390     try {
39391       (arg1)->OnChildRemove(*arg2);
39392     } catch (std::out_of_range& e) {
39393       {
39394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39395       };
39396     } catch (std::exception& e) {
39397       {
39398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39399       };
39400     } catch (Dali::DaliException e) {
39401       {
39402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39403       };
39404     } catch (...) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39407       };
39408     }
39409   }
39410
39411 }
39412
39413
39414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39415   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39416   Dali::Property::Index arg2 ;
39417   Dali::Property::Value arg3 ;
39418   Dali::Property::Value *argp3 ;
39419
39420   arg1 = (Dali::CustomActorImpl *)jarg1;
39421   arg2 = (Dali::Property::Index)jarg2;
39422   argp3 = (Dali::Property::Value *)jarg3;
39423   if (!argp3) {
39424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39425     return ;
39426   }
39427   arg3 = *argp3;
39428   {
39429     try {
39430       (arg1)->OnPropertySet(arg2,arg3);
39431     } catch (std::out_of_range& e) {
39432       {
39433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39434       };
39435     } catch (std::exception& e) {
39436       {
39437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39438       };
39439     } catch (Dali::DaliException e) {
39440       {
39441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39442       };
39443     } catch (...) {
39444       {
39445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39446       };
39447     }
39448   }
39449
39450 }
39451
39452
39453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39454   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39455   Dali::Vector3 *arg2 = 0 ;
39456
39457   arg1 = (Dali::CustomActorImpl *)jarg1;
39458   arg2 = (Dali::Vector3 *)jarg2;
39459   if (!arg2) {
39460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39461     return ;
39462   }
39463   {
39464     try {
39465       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39466     } catch (std::out_of_range& e) {
39467       {
39468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39469       };
39470     } catch (std::exception& e) {
39471       {
39472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39473       };
39474     } catch (Dali::DaliException e) {
39475       {
39476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39477       };
39478     } catch (...) {
39479       {
39480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39481       };
39482     }
39483   }
39484
39485 }
39486
39487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39488   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39489   Dali::Animation *arg2 = 0 ;
39490   Dali::Vector3 *arg3 = 0 ;
39491
39492   arg1 = (Dali::CustomActorImpl *)jarg1;
39493   arg2 = (Dali::Animation *)jarg2;
39494   if (!arg2) {
39495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39496     return ;
39497   }
39498   arg3 = (Dali::Vector3 *)jarg3;
39499   if (!arg3) {
39500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39501     return ;
39502   }
39503   {
39504     try {
39505       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39506     } catch (std::out_of_range& e) {
39507       {
39508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39509       };
39510     } catch (std::exception& e) {
39511       {
39512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39513       };
39514     } catch (Dali::DaliException e) {
39515       {
39516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39517       };
39518     } catch (...) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39521       };
39522     }
39523   }
39524
39525 }
39526
39527
39528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39529   unsigned int jresult ;
39530   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39531   Dali::TouchEvent *arg2 = 0 ;
39532   bool result;
39533
39534   arg1 = (Dali::CustomActorImpl *)jarg1;
39535   arg2 = (Dali::TouchEvent *)jarg2;
39536   if (!arg2) {
39537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39538     return 0;
39539   }
39540   {
39541     try {
39542       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39543     } catch (std::out_of_range& e) {
39544       {
39545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39546       };
39547     } catch (std::exception& e) {
39548       {
39549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39550       };
39551     } catch (Dali::DaliException e) {
39552       {
39553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39554       };
39555     } catch (...) {
39556       {
39557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39558       };
39559     }
39560   }
39561
39562   jresult = result;
39563   return jresult;
39564 }
39565
39566
39567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39568   unsigned int jresult ;
39569   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39570   Dali::HoverEvent *arg2 = 0 ;
39571   bool result;
39572
39573   arg1 = (Dali::CustomActorImpl *)jarg1;
39574   arg2 = (Dali::HoverEvent *)jarg2;
39575   if (!arg2) {
39576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39577     return 0;
39578   }
39579   {
39580     try {
39581       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39582     } catch (std::out_of_range& e) {
39583       {
39584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39585       };
39586     } catch (std::exception& e) {
39587       {
39588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39589       };
39590     } catch (Dali::DaliException e) {
39591       {
39592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39593       };
39594     } catch (...) {
39595       {
39596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39597       };
39598     }
39599   }
39600
39601   jresult = result;
39602   return jresult;
39603 }
39604
39605
39606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39607   unsigned int jresult ;
39608   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39609   Dali::KeyEvent *arg2 = 0 ;
39610   bool result;
39611
39612   arg1 = (Dali::CustomActorImpl *)jarg1;
39613   arg2 = (Dali::KeyEvent *)jarg2;
39614   if (!arg2) {
39615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39616     return 0;
39617   }
39618   {
39619     try {
39620       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39628       };
39629     } catch (Dali::DaliException e) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39632       };
39633     } catch (...) {
39634       {
39635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39636       };
39637     }
39638   }
39639
39640   jresult = result;
39641   return jresult;
39642 }
39643
39644
39645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39646   unsigned int jresult ;
39647   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39648   Dali::WheelEvent *arg2 = 0 ;
39649   bool result;
39650
39651   arg1 = (Dali::CustomActorImpl *)jarg1;
39652   arg2 = (Dali::WheelEvent *)jarg2;
39653   if (!arg2) {
39654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39655     return 0;
39656   }
39657   {
39658     try {
39659       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39660     } catch (std::out_of_range& e) {
39661       {
39662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39663       };
39664     } catch (std::exception& e) {
39665       {
39666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39667       };
39668     } catch (Dali::DaliException e) {
39669       {
39670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39671       };
39672     } catch (...) {
39673       {
39674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39675       };
39676     }
39677   }
39678
39679   jresult = result;
39680   return jresult;
39681 }
39682
39683
39684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39685   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39686   Dali::Vector2 *arg2 = 0 ;
39687   Dali::RelayoutContainer *arg3 = 0 ;
39688
39689   arg1 = (Dali::CustomActorImpl *)jarg1;
39690   arg2 = (Dali::Vector2 *)jarg2;
39691   if (!arg2) {
39692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39693     return ;
39694   }
39695   arg3 = (Dali::RelayoutContainer *)jarg3;
39696   if (!arg3) {
39697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39698     return ;
39699   }
39700   {
39701     try {
39702       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39703     } catch (std::out_of_range& e) {
39704       {
39705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39706       };
39707     } catch (std::exception& e) {
39708       {
39709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (Dali::DaliException e) {
39712       {
39713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39714       };
39715     } catch (...) {
39716       {
39717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39718       };
39719     }
39720   }
39721
39722 }
39723
39724
39725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39727   Dali::ResizePolicy::Type arg2 ;
39728   Dali::Dimension::Type arg3 ;
39729
39730   arg1 = (Dali::CustomActorImpl *)jarg1;
39731   arg2 = (Dali::ResizePolicy::Type)jarg2;
39732   arg3 = (Dali::Dimension::Type)jarg3;
39733   {
39734     try {
39735       (arg1)->OnSetResizePolicy(arg2,arg3);
39736     } catch (std::out_of_range& e) {
39737       {
39738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39739       };
39740     } catch (std::exception& e) {
39741       {
39742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39743       };
39744     } catch (Dali::DaliException e) {
39745       {
39746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39747       };
39748     } catch (...) {
39749       {
39750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39751       };
39752     }
39753   }
39754
39755 }
39756
39757
39758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39759   void * jresult ;
39760   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39761   Dali::Vector3 result;
39762
39763   arg1 = (Dali::CustomActorImpl *)jarg1;
39764   {
39765     try {
39766       result = (arg1)->GetNaturalSize();
39767     } catch (std::out_of_range& e) {
39768       {
39769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39770       };
39771     } catch (std::exception& e) {
39772       {
39773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39774       };
39775     } catch (Dali::DaliException e) {
39776       {
39777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39778       };
39779     } catch (...) {
39780       {
39781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39782       };
39783     }
39784   }
39785
39786   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39787   return jresult;
39788 }
39789
39790
39791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39792   float jresult ;
39793   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39794   Dali::Actor *arg2 = 0 ;
39795   Dali::Dimension::Type arg3 ;
39796   float result;
39797
39798   arg1 = (Dali::CustomActorImpl *)jarg1;
39799   arg2 = (Dali::Actor *)jarg2;
39800   if (!arg2) {
39801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39802     return 0;
39803   }
39804   arg3 = (Dali::Dimension::Type)jarg3;
39805   {
39806     try {
39807       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39808     } catch (std::out_of_range& e) {
39809       {
39810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39811       };
39812     } catch (std::exception& e) {
39813       {
39814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39815       };
39816     } catch (Dali::DaliException e) {
39817       {
39818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39819       };
39820     } catch (...) {
39821       {
39822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39823       };
39824     }
39825   }
39826
39827   jresult = result;
39828   return jresult;
39829 }
39830
39831
39832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39833   float jresult ;
39834   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39835   float arg2 ;
39836   float result;
39837
39838   arg1 = (Dali::CustomActorImpl *)jarg1;
39839   arg2 = (float)jarg2;
39840   {
39841     try {
39842       result = (float)(arg1)->GetHeightForWidth(arg2);
39843     } catch (std::out_of_range& e) {
39844       {
39845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39846       };
39847     } catch (std::exception& e) {
39848       {
39849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39850       };
39851     } catch (Dali::DaliException e) {
39852       {
39853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39854       };
39855     } catch (...) {
39856       {
39857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39858       };
39859     }
39860   }
39861
39862   jresult = result;
39863   return jresult;
39864 }
39865
39866
39867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39868   float jresult ;
39869   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39870   float arg2 ;
39871   float result;
39872
39873   arg1 = (Dali::CustomActorImpl *)jarg1;
39874   arg2 = (float)jarg2;
39875   {
39876     try {
39877       result = (float)(arg1)->GetWidthForHeight(arg2);
39878     } catch (std::out_of_range& e) {
39879       {
39880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39881       };
39882     } catch (std::exception& e) {
39883       {
39884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39885       };
39886     } catch (Dali::DaliException e) {
39887       {
39888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39889       };
39890     } catch (...) {
39891       {
39892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39893       };
39894     }
39895   }
39896
39897   jresult = result;
39898   return jresult;
39899 }
39900
39901
39902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39903   unsigned int jresult ;
39904   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39905   Dali::Dimension::Type arg2 ;
39906   bool result;
39907
39908   arg1 = (Dali::CustomActorImpl *)jarg1;
39909   arg2 = (Dali::Dimension::Type)jarg2;
39910   {
39911     try {
39912       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39913     } catch (std::out_of_range& e) {
39914       {
39915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39916       };
39917     } catch (std::exception& e) {
39918       {
39919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39920       };
39921     } catch (Dali::DaliException e) {
39922       {
39923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39924       };
39925     } catch (...) {
39926       {
39927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39928       };
39929     }
39930   }
39931
39932   jresult = result;
39933   return jresult;
39934 }
39935
39936
39937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39938   unsigned int jresult ;
39939   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39940   bool result;
39941
39942   arg1 = (Dali::CustomActorImpl *)jarg1;
39943   {
39944     try {
39945       result = (bool)(arg1)->RelayoutDependentOnChildren();
39946     } catch (std::out_of_range& e) {
39947       {
39948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39949       };
39950     } catch (std::exception& e) {
39951       {
39952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39953       };
39954     } catch (Dali::DaliException e) {
39955       {
39956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39957       };
39958     } catch (...) {
39959       {
39960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39961       };
39962     }
39963   }
39964
39965   jresult = result;
39966   return jresult;
39967 }
39968
39969
39970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39971   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39972   Dali::Dimension::Type arg2 ;
39973
39974   arg1 = (Dali::CustomActorImpl *)jarg1;
39975   arg2 = (Dali::Dimension::Type)jarg2;
39976   {
39977     try {
39978       (arg1)->OnCalculateRelayoutSize(arg2);
39979     } catch (std::out_of_range& e) {
39980       {
39981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39982       };
39983     } catch (std::exception& e) {
39984       {
39985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39986       };
39987     } catch (Dali::DaliException e) {
39988       {
39989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39990       };
39991     } catch (...) {
39992       {
39993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39994       };
39995     }
39996   }
39997
39998 }
39999
40000
40001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40002   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40003   float arg2 ;
40004   Dali::Dimension::Type arg3 ;
40005
40006   arg1 = (Dali::CustomActorImpl *)jarg1;
40007   arg2 = (float)jarg2;
40008   arg3 = (Dali::Dimension::Type)jarg3;
40009   {
40010     try {
40011       (arg1)->OnLayoutNegotiated(arg2,arg3);
40012     } catch (std::out_of_range& e) {
40013       {
40014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40015       };
40016     } catch (std::exception& e) {
40017       {
40018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40019       };
40020     } catch (Dali::DaliException e) {
40021       {
40022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40023       };
40024     } catch (...) {
40025       {
40026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40027       };
40028     }
40029   }
40030
40031 }
40032
40033
40034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40035   unsigned int jresult ;
40036   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40037   bool result;
40038
40039   arg1 = (Dali::CustomActorImpl *)jarg1;
40040   {
40041     try {
40042       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40043     } catch (std::out_of_range& e) {
40044       {
40045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40046       };
40047     } catch (std::exception& e) {
40048       {
40049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40050       };
40051     } catch (Dali::DaliException e) {
40052       {
40053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40054       };
40055     } catch (...) {
40056       {
40057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40058       };
40059     }
40060   }
40061
40062   jresult = result;
40063   return jresult;
40064 }
40065
40066
40067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40068   unsigned int jresult ;
40069   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40070   bool result;
40071
40072   arg1 = (Dali::CustomActorImpl *)jarg1;
40073   {
40074     try {
40075       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40076     } catch (std::out_of_range& e) {
40077       {
40078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40079       };
40080     } catch (std::exception& e) {
40081       {
40082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40083       };
40084     } catch (Dali::DaliException e) {
40085       {
40086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40087       };
40088     } catch (...) {
40089       {
40090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40091       };
40092     }
40093   }
40094
40095   jresult = result;
40096   return jresult;
40097 }
40098
40099
40100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40101   unsigned int jresult ;
40102   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40103   bool result;
40104
40105   arg1 = (Dali::CustomActorImpl *)jarg1;
40106   {
40107     try {
40108       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40109     } catch (std::out_of_range& e) {
40110       {
40111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40112       };
40113     } catch (std::exception& e) {
40114       {
40115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40116       };
40117     } catch (Dali::DaliException e) {
40118       {
40119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40120       };
40121     } catch (...) {
40122       {
40123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40124       };
40125     }
40126   }
40127
40128   jresult = result;
40129   return jresult;
40130 }
40131
40132
40133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40134   unsigned int jresult ;
40135   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40136   bool result;
40137
40138   arg1 = (Dali::CustomActorImpl *)jarg1;
40139   {
40140     try {
40141       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40142     } catch (std::out_of_range& e) {
40143       {
40144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40145       };
40146     } catch (std::exception& e) {
40147       {
40148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40149       };
40150     } catch (Dali::DaliException e) {
40151       {
40152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40153       };
40154     } catch (...) {
40155       {
40156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40157       };
40158     }
40159   }
40160
40161   jresult = result;
40162   return jresult;
40163 }
40164
40165
40166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40167   void * jresult ;
40168   Dali::CustomActor *result = 0 ;
40169
40170   {
40171     try {
40172       result = (Dali::CustomActor *)new Dali::CustomActor();
40173     } catch (std::out_of_range& e) {
40174       {
40175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40176       };
40177     } catch (std::exception& e) {
40178       {
40179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40180       };
40181     } catch (Dali::DaliException e) {
40182       {
40183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40184       };
40185     } catch (...) {
40186       {
40187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40188       };
40189     }
40190   }
40191
40192   jresult = (void *)result;
40193   return jresult;
40194 }
40195
40196
40197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40198   void * jresult ;
40199   Dali::BaseHandle arg1 ;
40200   Dali::BaseHandle *argp1 ;
40201   Dali::CustomActor result;
40202
40203   argp1 = (Dali::BaseHandle *)jarg1;
40204   if (!argp1) {
40205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40206     return 0;
40207   }
40208   arg1 = *argp1;
40209   {
40210     try {
40211       result = Dali::CustomActor::DownCast(arg1);
40212     } catch (std::out_of_range& e) {
40213       {
40214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40215       };
40216     } catch (std::exception& e) {
40217       {
40218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40219       };
40220     } catch (Dali::DaliException e) {
40221       {
40222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40223       };
40224     } catch (...) {
40225       {
40226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40227       };
40228     }
40229   }
40230
40231   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40232   return jresult;
40233 }
40234
40235
40236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40237   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40238
40239   arg1 = (Dali::CustomActor *)jarg1;
40240   {
40241     try {
40242       delete arg1;
40243     } catch (std::out_of_range& e) {
40244       {
40245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40246       };
40247     } catch (std::exception& e) {
40248       {
40249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40250       };
40251     } catch (Dali::DaliException e) {
40252       {
40253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40254       };
40255     } catch (...) {
40256       {
40257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40258       };
40259     }
40260   }
40261
40262 }
40263
40264
40265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40266   void * jresult ;
40267   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40268   Dali::CustomActorImpl *result = 0 ;
40269
40270   arg1 = (Dali::CustomActor *)jarg1;
40271   {
40272     try {
40273       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40274     } catch (std::out_of_range& e) {
40275       {
40276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40277       };
40278     } catch (std::exception& e) {
40279       {
40280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40281       };
40282     } catch (Dali::DaliException e) {
40283       {
40284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40285       };
40286     } catch (...) {
40287       {
40288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40289       };
40290     }
40291   }
40292
40293   jresult = (void *)result;
40294   return jresult;
40295 }
40296
40297
40298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40299   void * jresult ;
40300   Dali::CustomActorImpl *arg1 = 0 ;
40301   Dali::CustomActor *result = 0 ;
40302
40303   arg1 = (Dali::CustomActorImpl *)jarg1;
40304   if (!arg1) {
40305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40306     return 0;
40307   }
40308   {
40309     try {
40310       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40311     } catch (std::out_of_range& e) {
40312       {
40313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40314       };
40315     } catch (std::exception& e) {
40316       {
40317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40318       };
40319     } catch (Dali::DaliException e) {
40320       {
40321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40322       };
40323     } catch (...) {
40324       {
40325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40326       };
40327     }
40328   }
40329
40330   jresult = (void *)result;
40331   return jresult;
40332 }
40333
40334
40335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40336   void * jresult ;
40337   Dali::CustomActor *arg1 = 0 ;
40338   Dali::CustomActor *result = 0 ;
40339
40340   arg1 = (Dali::CustomActor *)jarg1;
40341   if (!arg1) {
40342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40343     return 0;
40344   }
40345   {
40346     try {
40347       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40348     } catch (std::out_of_range& e) {
40349       {
40350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40351       };
40352     } catch (std::exception& e) {
40353       {
40354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40355       };
40356     } catch (Dali::DaliException e) {
40357       {
40358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40359       };
40360     } catch (...) {
40361       {
40362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40363       };
40364     }
40365   }
40366
40367   jresult = (void *)result;
40368   return jresult;
40369 }
40370
40371
40372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40373   void * jresult ;
40374   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40375   Dali::CustomActor *arg2 = 0 ;
40376   Dali::CustomActor *result = 0 ;
40377
40378   arg1 = (Dali::CustomActor *)jarg1;
40379   arg2 = (Dali::CustomActor *)jarg2;
40380   if (!arg2) {
40381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40382     return 0;
40383   }
40384   {
40385     try {
40386       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40387     } catch (std::out_of_range& e) {
40388       {
40389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40390       };
40391     } catch (std::exception& e) {
40392       {
40393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40394       };
40395     } catch (Dali::DaliException e) {
40396       {
40397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40398       };
40399     } catch (...) {
40400       {
40401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40402       };
40403     }
40404   }
40405
40406   jresult = (void *)result;
40407   return jresult;
40408 }
40409
40410
40411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40412   int jresult ;
40413   int result;
40414
40415   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40416   jresult = (int)result;
40417   return jresult;
40418 }
40419
40420
40421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40422   int jresult ;
40423   int result;
40424
40425   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40426   jresult = (int)result;
40427   return jresult;
40428 }
40429
40430
40431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40432   int jresult ;
40433   int result;
40434
40435   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40436   jresult = (int)result;
40437   return jresult;
40438 }
40439
40440
40441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40442   int jresult ;
40443   int result;
40444
40445   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40446   jresult = (int)result;
40447   return jresult;
40448 }
40449
40450
40451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40452   int jresult ;
40453   int result;
40454
40455   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40456   jresult = (int)result;
40457   return jresult;
40458 }
40459
40460
40461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40462   int jresult ;
40463   int result;
40464
40465   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40466   jresult = (int)result;
40467   return jresult;
40468 }
40469
40470
40471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40472   int jresult ;
40473   int result;
40474
40475   result = (int)Dali::PanGestureDetector::Property::PANNING;
40476   jresult = (int)result;
40477   return jresult;
40478 }
40479
40480
40481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40482   void * jresult ;
40483   Dali::PanGestureDetector::Property *result = 0 ;
40484
40485   {
40486     try {
40487       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40488     } catch (std::out_of_range& e) {
40489       {
40490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40491       };
40492     } catch (std::exception& e) {
40493       {
40494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40495       };
40496     } catch (Dali::DaliException e) {
40497       {
40498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40499       };
40500     } catch (...) {
40501       {
40502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40503       };
40504     }
40505   }
40506
40507   jresult = (void *)result;
40508   return jresult;
40509 }
40510
40511
40512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40513   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40514
40515   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40516   {
40517     try {
40518       delete arg1;
40519     } catch (std::out_of_range& e) {
40520       {
40521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40522       };
40523     } catch (std::exception& e) {
40524       {
40525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40526       };
40527     } catch (Dali::DaliException e) {
40528       {
40529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40530       };
40531     } catch (...) {
40532       {
40533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40534       };
40535     }
40536   }
40537
40538 }
40539
40540
40541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40542   void * jresult ;
40543   Dali::Radian *result = 0 ;
40544
40545   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40546   jresult = (void *)result;
40547   return jresult;
40548 }
40549
40550
40551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40552   void * jresult ;
40553   Dali::Radian *result = 0 ;
40554
40555   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40556   jresult = (void *)result;
40557   return jresult;
40558 }
40559
40560
40561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40562   void * jresult ;
40563   Dali::Radian *result = 0 ;
40564
40565   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40566   jresult = (void *)result;
40567   return jresult;
40568 }
40569
40570
40571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40572   void * jresult ;
40573   Dali::Radian *result = 0 ;
40574
40575   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40576   jresult = (void *)result;
40577   return jresult;
40578 }
40579
40580
40581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40582   void * jresult ;
40583   Dali::Radian *result = 0 ;
40584
40585   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40586   jresult = (void *)result;
40587   return jresult;
40588 }
40589
40590
40591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40592   void * jresult ;
40593   Dali::Radian *result = 0 ;
40594
40595   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40596   jresult = (void *)result;
40597   return jresult;
40598 }
40599
40600
40601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40602   void * jresult ;
40603   Dali::Radian *result = 0 ;
40604
40605   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40606   jresult = (void *)result;
40607   return jresult;
40608 }
40609
40610
40611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40612   void * jresult ;
40613   Dali::PanGestureDetector *result = 0 ;
40614
40615   {
40616     try {
40617       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40618     } catch (std::out_of_range& e) {
40619       {
40620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40621       };
40622     } catch (std::exception& e) {
40623       {
40624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40625       };
40626     } catch (Dali::DaliException e) {
40627       {
40628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40629       };
40630     } catch (...) {
40631       {
40632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40633       };
40634     }
40635   }
40636
40637   jresult = (void *)result;
40638   return jresult;
40639 }
40640
40641
40642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40643   void * jresult ;
40644   Dali::PanGestureDetector result;
40645
40646   {
40647     try {
40648       result = Dali::PanGestureDetector::New();
40649     } catch (std::out_of_range& e) {
40650       {
40651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40652       };
40653     } catch (std::exception& e) {
40654       {
40655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40656       };
40657     } catch (Dali::DaliException e) {
40658       {
40659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40660       };
40661     } catch (...) {
40662       {
40663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40664       };
40665     }
40666   }
40667
40668   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40669   return jresult;
40670 }
40671
40672
40673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40674   void * jresult ;
40675   Dali::BaseHandle arg1 ;
40676   Dali::BaseHandle *argp1 ;
40677   Dali::PanGestureDetector result;
40678
40679   argp1 = (Dali::BaseHandle *)jarg1;
40680   if (!argp1) {
40681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40682     return 0;
40683   }
40684   arg1 = *argp1;
40685   {
40686     try {
40687       result = Dali::PanGestureDetector::DownCast(arg1);
40688     } catch (std::out_of_range& e) {
40689       {
40690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40691       };
40692     } catch (std::exception& e) {
40693       {
40694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40695       };
40696     } catch (Dali::DaliException e) {
40697       {
40698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40699       };
40700     } catch (...) {
40701       {
40702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40703       };
40704     }
40705   }
40706
40707   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40708   return jresult;
40709 }
40710
40711
40712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40713   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40714
40715   arg1 = (Dali::PanGestureDetector *)jarg1;
40716   {
40717     try {
40718       delete arg1;
40719     } catch (std::out_of_range& e) {
40720       {
40721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40722       };
40723     } catch (std::exception& e) {
40724       {
40725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40726       };
40727     } catch (Dali::DaliException e) {
40728       {
40729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40730       };
40731     } catch (...) {
40732       {
40733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40734       };
40735     }
40736   }
40737
40738 }
40739
40740
40741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40742   void * jresult ;
40743   Dali::PanGestureDetector *arg1 = 0 ;
40744   Dali::PanGestureDetector *result = 0 ;
40745
40746   arg1 = (Dali::PanGestureDetector *)jarg1;
40747   if (!arg1) {
40748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40749     return 0;
40750   }
40751   {
40752     try {
40753       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40754     } catch (std::out_of_range& e) {
40755       {
40756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40757       };
40758     } catch (std::exception& e) {
40759       {
40760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40761       };
40762     } catch (Dali::DaliException e) {
40763       {
40764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40765       };
40766     } catch (...) {
40767       {
40768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40769       };
40770     }
40771   }
40772
40773   jresult = (void *)result;
40774   return jresult;
40775 }
40776
40777
40778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40779   void * jresult ;
40780   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40781   Dali::PanGestureDetector *arg2 = 0 ;
40782   Dali::PanGestureDetector *result = 0 ;
40783
40784   arg1 = (Dali::PanGestureDetector *)jarg1;
40785   arg2 = (Dali::PanGestureDetector *)jarg2;
40786   if (!arg2) {
40787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40788     return 0;
40789   }
40790   {
40791     try {
40792       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40793     } catch (std::out_of_range& e) {
40794       {
40795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40796       };
40797     } catch (std::exception& e) {
40798       {
40799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40800       };
40801     } catch (Dali::DaliException e) {
40802       {
40803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40804       };
40805     } catch (...) {
40806       {
40807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40808       };
40809     }
40810   }
40811
40812   jresult = (void *)result;
40813   return jresult;
40814 }
40815
40816
40817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40818   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40819   unsigned int arg2 ;
40820
40821   arg1 = (Dali::PanGestureDetector *)jarg1;
40822   arg2 = (unsigned int)jarg2;
40823   {
40824     try {
40825       (arg1)->SetMinimumTouchesRequired(arg2);
40826     } catch (std::out_of_range& e) {
40827       {
40828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40829       };
40830     } catch (std::exception& e) {
40831       {
40832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40833       };
40834     } catch (Dali::DaliException e) {
40835       {
40836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40837       };
40838     } catch (...) {
40839       {
40840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40841       };
40842     }
40843   }
40844
40845 }
40846
40847
40848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40849   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40850   unsigned int arg2 ;
40851
40852   arg1 = (Dali::PanGestureDetector *)jarg1;
40853   arg2 = (unsigned int)jarg2;
40854   {
40855     try {
40856       (arg1)->SetMaximumTouchesRequired(arg2);
40857     } catch (std::out_of_range& e) {
40858       {
40859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40860       };
40861     } catch (std::exception& e) {
40862       {
40863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40864       };
40865     } catch (Dali::DaliException e) {
40866       {
40867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40868       };
40869     } catch (...) {
40870       {
40871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40872       };
40873     }
40874   }
40875
40876 }
40877
40878
40879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40880   unsigned int jresult ;
40881   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40882   unsigned int result;
40883
40884   arg1 = (Dali::PanGestureDetector *)jarg1;
40885   {
40886     try {
40887       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40888     } catch (std::out_of_range& e) {
40889       {
40890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40891       };
40892     } catch (std::exception& e) {
40893       {
40894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40895       };
40896     } catch (Dali::DaliException e) {
40897       {
40898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40899       };
40900     } catch (...) {
40901       {
40902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40903       };
40904     }
40905   }
40906
40907   jresult = result;
40908   return jresult;
40909 }
40910
40911
40912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40913   unsigned int jresult ;
40914   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40915   unsigned int result;
40916
40917   arg1 = (Dali::PanGestureDetector *)jarg1;
40918   {
40919     try {
40920       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40921     } catch (std::out_of_range& e) {
40922       {
40923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40924       };
40925     } catch (std::exception& e) {
40926       {
40927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40928       };
40929     } catch (Dali::DaliException e) {
40930       {
40931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40932       };
40933     } catch (...) {
40934       {
40935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40936       };
40937     }
40938   }
40939
40940   jresult = result;
40941   return jresult;
40942 }
40943
40944
40945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40946   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40947   Dali::Radian arg2 ;
40948   Dali::Radian arg3 ;
40949   Dali::Radian *argp2 ;
40950   Dali::Radian *argp3 ;
40951
40952   arg1 = (Dali::PanGestureDetector *)jarg1;
40953   argp2 = (Dali::Radian *)jarg2;
40954   if (!argp2) {
40955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40956     return ;
40957   }
40958   arg2 = *argp2;
40959   argp3 = (Dali::Radian *)jarg3;
40960   if (!argp3) {
40961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40962     return ;
40963   }
40964   arg3 = *argp3;
40965   {
40966     try {
40967       (arg1)->AddAngle(arg2,arg3);
40968     } catch (std::out_of_range& e) {
40969       {
40970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40971       };
40972     } catch (std::exception& e) {
40973       {
40974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40975       };
40976     } catch (Dali::DaliException e) {
40977       {
40978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40979       };
40980     } catch (...) {
40981       {
40982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40983       };
40984     }
40985   }
40986
40987 }
40988
40989
40990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40991   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40992   Dali::Radian arg2 ;
40993   Dali::Radian *argp2 ;
40994
40995   arg1 = (Dali::PanGestureDetector *)jarg1;
40996   argp2 = (Dali::Radian *)jarg2;
40997   if (!argp2) {
40998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40999     return ;
41000   }
41001   arg2 = *argp2;
41002   {
41003     try {
41004       (arg1)->AddAngle(arg2);
41005     } catch (std::out_of_range& e) {
41006       {
41007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41008       };
41009     } catch (std::exception& e) {
41010       {
41011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41012       };
41013     } catch (Dali::DaliException e) {
41014       {
41015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41016       };
41017     } catch (...) {
41018       {
41019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41020       };
41021     }
41022   }
41023
41024 }
41025
41026
41027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41028   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41029   Dali::Radian arg2 ;
41030   Dali::Radian arg3 ;
41031   Dali::Radian *argp2 ;
41032   Dali::Radian *argp3 ;
41033
41034   arg1 = (Dali::PanGestureDetector *)jarg1;
41035   argp2 = (Dali::Radian *)jarg2;
41036   if (!argp2) {
41037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41038     return ;
41039   }
41040   arg2 = *argp2;
41041   argp3 = (Dali::Radian *)jarg3;
41042   if (!argp3) {
41043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41044     return ;
41045   }
41046   arg3 = *argp3;
41047   {
41048     try {
41049       (arg1)->AddDirection(arg2,arg3);
41050     } catch (std::out_of_range& e) {
41051       {
41052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41053       };
41054     } catch (std::exception& e) {
41055       {
41056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41057       };
41058     } catch (Dali::DaliException e) {
41059       {
41060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41061       };
41062     } catch (...) {
41063       {
41064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41065       };
41066     }
41067   }
41068
41069 }
41070
41071
41072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41073   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41074   Dali::Radian arg2 ;
41075   Dali::Radian *argp2 ;
41076
41077   arg1 = (Dali::PanGestureDetector *)jarg1;
41078   argp2 = (Dali::Radian *)jarg2;
41079   if (!argp2) {
41080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41081     return ;
41082   }
41083   arg2 = *argp2;
41084   {
41085     try {
41086       (arg1)->AddDirection(arg2);
41087     } catch (std::out_of_range& e) {
41088       {
41089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41090       };
41091     } catch (std::exception& e) {
41092       {
41093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41094       };
41095     } catch (Dali::DaliException e) {
41096       {
41097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41098       };
41099     } catch (...) {
41100       {
41101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41102       };
41103     }
41104   }
41105
41106 }
41107
41108
41109 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41110   unsigned long jresult ;
41111   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41112   size_t result;
41113
41114   arg1 = (Dali::PanGestureDetector *)jarg1;
41115   {
41116     try {
41117       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41118     } catch (std::out_of_range& e) {
41119       {
41120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41121       };
41122     } catch (std::exception& e) {
41123       {
41124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41125       };
41126     } catch (Dali::DaliException e) {
41127       {
41128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41129       };
41130     } catch (...) {
41131       {
41132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41133       };
41134     }
41135   }
41136
41137   jresult = (unsigned long)result;
41138   return jresult;
41139 }
41140
41141
41142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41143   void * jresult ;
41144   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41145   size_t arg2 ;
41146   Dali::PanGestureDetector::AngleThresholdPair result;
41147
41148   arg1 = (Dali::PanGestureDetector *)jarg1;
41149   arg2 = (size_t)jarg2;
41150   {
41151     try {
41152       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41153     } catch (std::out_of_range& e) {
41154       {
41155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41156       };
41157     } catch (std::exception& e) {
41158       {
41159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41160       };
41161     } catch (Dali::DaliException e) {
41162       {
41163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41164       };
41165     } catch (...) {
41166       {
41167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41168       };
41169     }
41170   }
41171
41172   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41173   return jresult;
41174 }
41175
41176
41177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41178   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41179
41180   arg1 = (Dali::PanGestureDetector *)jarg1;
41181   {
41182     try {
41183       (arg1)->ClearAngles();
41184     } catch (std::out_of_range& e) {
41185       {
41186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41187       };
41188     } catch (std::exception& e) {
41189       {
41190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41191       };
41192     } catch (Dali::DaliException e) {
41193       {
41194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41195       };
41196     } catch (...) {
41197       {
41198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41199       };
41200     }
41201   }
41202
41203 }
41204
41205
41206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41207   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41208   Dali::Radian arg2 ;
41209   Dali::Radian *argp2 ;
41210
41211   arg1 = (Dali::PanGestureDetector *)jarg1;
41212   argp2 = (Dali::Radian *)jarg2;
41213   if (!argp2) {
41214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41215     return ;
41216   }
41217   arg2 = *argp2;
41218   {
41219     try {
41220       (arg1)->RemoveAngle(arg2);
41221     } catch (std::out_of_range& e) {
41222       {
41223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41224       };
41225     } catch (std::exception& e) {
41226       {
41227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41228       };
41229     } catch (Dali::DaliException e) {
41230       {
41231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41232       };
41233     } catch (...) {
41234       {
41235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41236       };
41237     }
41238   }
41239
41240 }
41241
41242
41243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41244   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41245   Dali::Radian arg2 ;
41246   Dali::Radian *argp2 ;
41247
41248   arg1 = (Dali::PanGestureDetector *)jarg1;
41249   argp2 = (Dali::Radian *)jarg2;
41250   if (!argp2) {
41251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41252     return ;
41253   }
41254   arg2 = *argp2;
41255   {
41256     try {
41257       (arg1)->RemoveDirection(arg2);
41258     } catch (std::out_of_range& e) {
41259       {
41260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41261       };
41262     } catch (std::exception& e) {
41263       {
41264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41265       };
41266     } catch (Dali::DaliException e) {
41267       {
41268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41269       };
41270     } catch (...) {
41271       {
41272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41273       };
41274     }
41275   }
41276
41277 }
41278
41279
41280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41281   void * jresult ;
41282   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41283   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41284
41285   arg1 = (Dali::PanGestureDetector *)jarg1;
41286   {
41287     try {
41288       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41289     } catch (std::out_of_range& e) {
41290       {
41291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41292       };
41293     } catch (std::exception& e) {
41294       {
41295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41296       };
41297     } catch (Dali::DaliException e) {
41298       {
41299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41300       };
41301     } catch (...) {
41302       {
41303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41304       };
41305     }
41306   }
41307
41308   jresult = (void *)result;
41309   return jresult;
41310 }
41311
41312
41313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41314   Dali::PanGesture *arg1 = 0 ;
41315
41316   arg1 = (Dali::PanGesture *)jarg1;
41317   if (!arg1) {
41318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41319     return ;
41320   }
41321   {
41322     try {
41323       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41324     } catch (std::out_of_range& e) {
41325       {
41326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41327       };
41328     } catch (std::exception& e) {
41329       {
41330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41331       };
41332     } catch (Dali::DaliException e) {
41333       {
41334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41335       };
41336     } catch (...) {
41337       {
41338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41339       };
41340     }
41341   }
41342
41343 }
41344
41345
41346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41347   void * jresult ;
41348   Dali::PanGesture *result = 0 ;
41349
41350   {
41351     try {
41352       result = (Dali::PanGesture *)new Dali::PanGesture();
41353     } catch (std::out_of_range& e) {
41354       {
41355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41356       };
41357     } catch (std::exception& e) {
41358       {
41359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41360       };
41361     } catch (Dali::DaliException e) {
41362       {
41363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41364       };
41365     } catch (...) {
41366       {
41367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41368       };
41369     }
41370   }
41371
41372   jresult = (void *)result;
41373   return jresult;
41374 }
41375
41376
41377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41378   void * jresult ;
41379   Dali::Gesture::State arg1 ;
41380   Dali::PanGesture *result = 0 ;
41381
41382   arg1 = (Dali::Gesture::State)jarg1;
41383   {
41384     try {
41385       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41386     } catch (std::out_of_range& e) {
41387       {
41388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41389       };
41390     } catch (std::exception& e) {
41391       {
41392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41393       };
41394     } catch (Dali::DaliException e) {
41395       {
41396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41397       };
41398     } catch (...) {
41399       {
41400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41401       };
41402     }
41403   }
41404
41405   jresult = (void *)result;
41406   return jresult;
41407 }
41408
41409
41410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41411   void * jresult ;
41412   Dali::PanGesture *arg1 = 0 ;
41413   Dali::PanGesture *result = 0 ;
41414
41415   arg1 = (Dali::PanGesture *)jarg1;
41416   if (!arg1) {
41417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41418     return 0;
41419   }
41420   {
41421     try {
41422       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41423     } catch (std::out_of_range& e) {
41424       {
41425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41426       };
41427     } catch (std::exception& e) {
41428       {
41429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41430       };
41431     } catch (Dali::DaliException e) {
41432       {
41433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41434       };
41435     } catch (...) {
41436       {
41437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41438       };
41439     }
41440   }
41441
41442   jresult = (void *)result;
41443   return jresult;
41444 }
41445
41446
41447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41448   void * jresult ;
41449   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41450   Dali::PanGesture *arg2 = 0 ;
41451   Dali::PanGesture *result = 0 ;
41452
41453   arg1 = (Dali::PanGesture *)jarg1;
41454   arg2 = (Dali::PanGesture *)jarg2;
41455   if (!arg2) {
41456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41457     return 0;
41458   }
41459   {
41460     try {
41461       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41462     } catch (std::out_of_range& e) {
41463       {
41464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41465       };
41466     } catch (std::exception& e) {
41467       {
41468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41469       };
41470     } catch (Dali::DaliException e) {
41471       {
41472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41473       };
41474     } catch (...) {
41475       {
41476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41477       };
41478     }
41479   }
41480
41481   jresult = (void *)result;
41482   return jresult;
41483 }
41484
41485
41486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41487   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41488
41489   arg1 = (Dali::PanGesture *)jarg1;
41490   {
41491     try {
41492       delete arg1;
41493     } catch (std::out_of_range& e) {
41494       {
41495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41496       };
41497     } catch (std::exception& e) {
41498       {
41499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41500       };
41501     } catch (Dali::DaliException e) {
41502       {
41503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41504       };
41505     } catch (...) {
41506       {
41507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41508       };
41509     }
41510   }
41511
41512 }
41513
41514
41515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41516   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41517   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41518
41519   arg1 = (Dali::PanGesture *)jarg1;
41520   arg2 = (Dali::Vector2 *)jarg2;
41521   if (arg1) (arg1)->velocity = *arg2;
41522 }
41523
41524
41525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41526   void * jresult ;
41527   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41528   Dali::Vector2 *result = 0 ;
41529
41530   arg1 = (Dali::PanGesture *)jarg1;
41531   result = (Dali::Vector2 *)& ((arg1)->velocity);
41532   jresult = (void *)result;
41533   return jresult;
41534 }
41535
41536
41537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41538   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41539   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41540
41541   arg1 = (Dali::PanGesture *)jarg1;
41542   arg2 = (Dali::Vector2 *)jarg2;
41543   if (arg1) (arg1)->displacement = *arg2;
41544 }
41545
41546
41547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41548   void * jresult ;
41549   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41550   Dali::Vector2 *result = 0 ;
41551
41552   arg1 = (Dali::PanGesture *)jarg1;
41553   result = (Dali::Vector2 *)& ((arg1)->displacement);
41554   jresult = (void *)result;
41555   return jresult;
41556 }
41557
41558
41559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41560   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41561   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41562
41563   arg1 = (Dali::PanGesture *)jarg1;
41564   arg2 = (Dali::Vector2 *)jarg2;
41565   if (arg1) (arg1)->position = *arg2;
41566 }
41567
41568
41569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41570   void * jresult ;
41571   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41572   Dali::Vector2 *result = 0 ;
41573
41574   arg1 = (Dali::PanGesture *)jarg1;
41575   result = (Dali::Vector2 *)& ((arg1)->position);
41576   jresult = (void *)result;
41577   return jresult;
41578 }
41579
41580
41581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41582   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41583   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41584
41585   arg1 = (Dali::PanGesture *)jarg1;
41586   arg2 = (Dali::Vector2 *)jarg2;
41587   if (arg1) (arg1)->screenVelocity = *arg2;
41588 }
41589
41590
41591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41592   void * jresult ;
41593   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41594   Dali::Vector2 *result = 0 ;
41595
41596   arg1 = (Dali::PanGesture *)jarg1;
41597   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41598   jresult = (void *)result;
41599   return jresult;
41600 }
41601
41602
41603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41604   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41605   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41606
41607   arg1 = (Dali::PanGesture *)jarg1;
41608   arg2 = (Dali::Vector2 *)jarg2;
41609   if (arg1) (arg1)->screenDisplacement = *arg2;
41610 }
41611
41612
41613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41614   void * jresult ;
41615   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41616   Dali::Vector2 *result = 0 ;
41617
41618   arg1 = (Dali::PanGesture *)jarg1;
41619   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41620   jresult = (void *)result;
41621   return jresult;
41622 }
41623
41624
41625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41626   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41627   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41628
41629   arg1 = (Dali::PanGesture *)jarg1;
41630   arg2 = (Dali::Vector2 *)jarg2;
41631   if (arg1) (arg1)->screenPosition = *arg2;
41632 }
41633
41634
41635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41636   void * jresult ;
41637   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41638   Dali::Vector2 *result = 0 ;
41639
41640   arg1 = (Dali::PanGesture *)jarg1;
41641   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41642   jresult = (void *)result;
41643   return jresult;
41644 }
41645
41646
41647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41648   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41649   unsigned int arg2 ;
41650
41651   arg1 = (Dali::PanGesture *)jarg1;
41652   arg2 = (unsigned int)jarg2;
41653   if (arg1) (arg1)->numberOfTouches = arg2;
41654 }
41655
41656
41657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41658   unsigned int jresult ;
41659   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41660   unsigned int result;
41661
41662   arg1 = (Dali::PanGesture *)jarg1;
41663   result = (unsigned int) ((arg1)->numberOfTouches);
41664   jresult = result;
41665   return jresult;
41666 }
41667
41668
41669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41670   float jresult ;
41671   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41672   float result;
41673
41674   arg1 = (Dali::PanGesture *)jarg1;
41675   {
41676     try {
41677       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41678     } catch (std::out_of_range& e) {
41679       {
41680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41681       };
41682     } catch (std::exception& e) {
41683       {
41684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41685       };
41686     } catch (Dali::DaliException e) {
41687       {
41688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41689       };
41690     } catch (...) {
41691       {
41692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41693       };
41694     }
41695   }
41696
41697   jresult = result;
41698   return jresult;
41699 }
41700
41701
41702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41703   float jresult ;
41704   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41705   float result;
41706
41707   arg1 = (Dali::PanGesture *)jarg1;
41708   {
41709     try {
41710       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41711     } catch (std::out_of_range& e) {
41712       {
41713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41714       };
41715     } catch (std::exception& e) {
41716       {
41717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41718       };
41719     } catch (Dali::DaliException e) {
41720       {
41721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41722       };
41723     } catch (...) {
41724       {
41725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41726       };
41727     }
41728   }
41729
41730   jresult = result;
41731   return jresult;
41732 }
41733
41734
41735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41736   float jresult ;
41737   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41738   float result;
41739
41740   arg1 = (Dali::PanGesture *)jarg1;
41741   {
41742     try {
41743       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41744     } catch (std::out_of_range& e) {
41745       {
41746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41747       };
41748     } catch (std::exception& e) {
41749       {
41750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41751       };
41752     } catch (Dali::DaliException e) {
41753       {
41754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41755       };
41756     } catch (...) {
41757       {
41758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41759       };
41760     }
41761   }
41762
41763   jresult = result;
41764   return jresult;
41765 }
41766
41767
41768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41769   float jresult ;
41770   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41771   float result;
41772
41773   arg1 = (Dali::PanGesture *)jarg1;
41774   {
41775     try {
41776       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41777     } catch (std::out_of_range& e) {
41778       {
41779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41780       };
41781     } catch (std::exception& e) {
41782       {
41783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41784       };
41785     } catch (Dali::DaliException e) {
41786       {
41787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41788       };
41789     } catch (...) {
41790       {
41791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41792       };
41793     }
41794   }
41795
41796   jresult = result;
41797   return jresult;
41798 }
41799
41800
41801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41802   void * jresult ;
41803   Dali::PinchGestureDetector *result = 0 ;
41804
41805   {
41806     try {
41807       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41808     } catch (std::out_of_range& e) {
41809       {
41810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41811       };
41812     } catch (std::exception& e) {
41813       {
41814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41815       };
41816     } catch (Dali::DaliException e) {
41817       {
41818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41819       };
41820     } catch (...) {
41821       {
41822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41823       };
41824     }
41825   }
41826
41827   jresult = (void *)result;
41828   return jresult;
41829 }
41830
41831
41832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41833   void * jresult ;
41834   Dali::PinchGestureDetector result;
41835
41836   {
41837     try {
41838       result = Dali::PinchGestureDetector::New();
41839     } catch (std::out_of_range& e) {
41840       {
41841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41842       };
41843     } catch (std::exception& e) {
41844       {
41845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41846       };
41847     } catch (Dali::DaliException e) {
41848       {
41849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41850       };
41851     } catch (...) {
41852       {
41853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41854       };
41855     }
41856   }
41857
41858   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41859   return jresult;
41860 }
41861
41862
41863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41864   void * jresult ;
41865   Dali::BaseHandle arg1 ;
41866   Dali::BaseHandle *argp1 ;
41867   Dali::PinchGestureDetector result;
41868
41869   argp1 = (Dali::BaseHandle *)jarg1;
41870   if (!argp1) {
41871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41872     return 0;
41873   }
41874   arg1 = *argp1;
41875   {
41876     try {
41877       result = Dali::PinchGestureDetector::DownCast(arg1);
41878     } catch (std::out_of_range& e) {
41879       {
41880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41881       };
41882     } catch (std::exception& e) {
41883       {
41884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41885       };
41886     } catch (Dali::DaliException e) {
41887       {
41888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41889       };
41890     } catch (...) {
41891       {
41892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41893       };
41894     }
41895   }
41896
41897   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41898   return jresult;
41899 }
41900
41901
41902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41903   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41904
41905   arg1 = (Dali::PinchGestureDetector *)jarg1;
41906   {
41907     try {
41908       delete arg1;
41909     } catch (std::out_of_range& e) {
41910       {
41911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41912       };
41913     } catch (std::exception& e) {
41914       {
41915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41916       };
41917     } catch (Dali::DaliException e) {
41918       {
41919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41920       };
41921     } catch (...) {
41922       {
41923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41924       };
41925     }
41926   }
41927
41928 }
41929
41930
41931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41932   void * jresult ;
41933   Dali::PinchGestureDetector *arg1 = 0 ;
41934   Dali::PinchGestureDetector *result = 0 ;
41935
41936   arg1 = (Dali::PinchGestureDetector *)jarg1;
41937   if (!arg1) {
41938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41939     return 0;
41940   }
41941   {
41942     try {
41943       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41944     } catch (std::out_of_range& e) {
41945       {
41946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41947       };
41948     } catch (std::exception& e) {
41949       {
41950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41951       };
41952     } catch (Dali::DaliException e) {
41953       {
41954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41955       };
41956     } catch (...) {
41957       {
41958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41959       };
41960     }
41961   }
41962
41963   jresult = (void *)result;
41964   return jresult;
41965 }
41966
41967
41968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41969   void * jresult ;
41970   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41971   Dali::PinchGestureDetector *arg2 = 0 ;
41972   Dali::PinchGestureDetector *result = 0 ;
41973
41974   arg1 = (Dali::PinchGestureDetector *)jarg1;
41975   arg2 = (Dali::PinchGestureDetector *)jarg2;
41976   if (!arg2) {
41977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41978     return 0;
41979   }
41980   {
41981     try {
41982       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41983     } catch (std::out_of_range& e) {
41984       {
41985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41986       };
41987     } catch (std::exception& e) {
41988       {
41989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41990       };
41991     } catch (Dali::DaliException e) {
41992       {
41993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41994       };
41995     } catch (...) {
41996       {
41997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41998       };
41999     }
42000   }
42001
42002   jresult = (void *)result;
42003   return jresult;
42004 }
42005
42006
42007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42008   void * jresult ;
42009   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42010   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42011
42012   arg1 = (Dali::PinchGestureDetector *)jarg1;
42013   {
42014     try {
42015       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42016     } catch (std::out_of_range& e) {
42017       {
42018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42019       };
42020     } catch (std::exception& e) {
42021       {
42022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42023       };
42024     } catch (Dali::DaliException e) {
42025       {
42026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42027       };
42028     } catch (...) {
42029       {
42030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42031       };
42032     }
42033   }
42034
42035   jresult = (void *)result;
42036   return jresult;
42037 }
42038
42039
42040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42041   void * jresult ;
42042   Dali::Gesture::State arg1 ;
42043   Dali::PinchGesture *result = 0 ;
42044
42045   arg1 = (Dali::Gesture::State)jarg1;
42046   {
42047     try {
42048       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42049     } catch (std::out_of_range& e) {
42050       {
42051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42052       };
42053     } catch (std::exception& e) {
42054       {
42055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42056       };
42057     } catch (Dali::DaliException e) {
42058       {
42059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42060       };
42061     } catch (...) {
42062       {
42063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42064       };
42065     }
42066   }
42067
42068   jresult = (void *)result;
42069   return jresult;
42070 }
42071
42072
42073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42074   void * jresult ;
42075   Dali::PinchGesture *arg1 = 0 ;
42076   Dali::PinchGesture *result = 0 ;
42077
42078   arg1 = (Dali::PinchGesture *)jarg1;
42079   if (!arg1) {
42080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42081     return 0;
42082   }
42083   {
42084     try {
42085       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42086     } catch (std::out_of_range& e) {
42087       {
42088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42089       };
42090     } catch (std::exception& e) {
42091       {
42092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42093       };
42094     } catch (Dali::DaliException e) {
42095       {
42096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42097       };
42098     } catch (...) {
42099       {
42100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42101       };
42102     }
42103   }
42104
42105   jresult = (void *)result;
42106   return jresult;
42107 }
42108
42109
42110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42111   void * jresult ;
42112   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42113   Dali::PinchGesture *arg2 = 0 ;
42114   Dali::PinchGesture *result = 0 ;
42115
42116   arg1 = (Dali::PinchGesture *)jarg1;
42117   arg2 = (Dali::PinchGesture *)jarg2;
42118   if (!arg2) {
42119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42120     return 0;
42121   }
42122   {
42123     try {
42124       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42125     } catch (std::out_of_range& e) {
42126       {
42127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42128       };
42129     } catch (std::exception& e) {
42130       {
42131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42132       };
42133     } catch (Dali::DaliException e) {
42134       {
42135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42136       };
42137     } catch (...) {
42138       {
42139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42140       };
42141     }
42142   }
42143
42144   jresult = (void *)result;
42145   return jresult;
42146 }
42147
42148
42149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42150   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42151
42152   arg1 = (Dali::PinchGesture *)jarg1;
42153   {
42154     try {
42155       delete arg1;
42156     } catch (std::out_of_range& e) {
42157       {
42158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42159       };
42160     } catch (std::exception& e) {
42161       {
42162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42163       };
42164     } catch (Dali::DaliException e) {
42165       {
42166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42167       };
42168     } catch (...) {
42169       {
42170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42171       };
42172     }
42173   }
42174
42175 }
42176
42177
42178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42179   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42180   float arg2 ;
42181
42182   arg1 = (Dali::PinchGesture *)jarg1;
42183   arg2 = (float)jarg2;
42184   if (arg1) (arg1)->scale = arg2;
42185 }
42186
42187
42188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42189   float jresult ;
42190   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42191   float result;
42192
42193   arg1 = (Dali::PinchGesture *)jarg1;
42194   result = (float) ((arg1)->scale);
42195   jresult = result;
42196   return jresult;
42197 }
42198
42199
42200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42201   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42202   float arg2 ;
42203
42204   arg1 = (Dali::PinchGesture *)jarg1;
42205   arg2 = (float)jarg2;
42206   if (arg1) (arg1)->speed = arg2;
42207 }
42208
42209
42210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42211   float jresult ;
42212   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42213   float result;
42214
42215   arg1 = (Dali::PinchGesture *)jarg1;
42216   result = (float) ((arg1)->speed);
42217   jresult = result;
42218   return jresult;
42219 }
42220
42221
42222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42223   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42224   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42225
42226   arg1 = (Dali::PinchGesture *)jarg1;
42227   arg2 = (Dali::Vector2 *)jarg2;
42228   if (arg1) (arg1)->screenCenterPoint = *arg2;
42229 }
42230
42231
42232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42233   void * jresult ;
42234   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42235   Dali::Vector2 *result = 0 ;
42236
42237   arg1 = (Dali::PinchGesture *)jarg1;
42238   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42239   jresult = (void *)result;
42240   return jresult;
42241 }
42242
42243
42244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42245   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42246   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42247
42248   arg1 = (Dali::PinchGesture *)jarg1;
42249   arg2 = (Dali::Vector2 *)jarg2;
42250   if (arg1) (arg1)->localCenterPoint = *arg2;
42251 }
42252
42253
42254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42255   void * jresult ;
42256   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42257   Dali::Vector2 *result = 0 ;
42258
42259   arg1 = (Dali::PinchGesture *)jarg1;
42260   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42261   jresult = (void *)result;
42262   return jresult;
42263 }
42264
42265
42266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42267   void * jresult ;
42268   Dali::TapGestureDetector *result = 0 ;
42269
42270   {
42271     try {
42272       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42273     } catch (std::out_of_range& e) {
42274       {
42275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42276       };
42277     } catch (std::exception& e) {
42278       {
42279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42280       };
42281     } catch (Dali::DaliException e) {
42282       {
42283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42284       };
42285     } catch (...) {
42286       {
42287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42288       };
42289     }
42290   }
42291
42292   jresult = (void *)result;
42293   return jresult;
42294 }
42295
42296
42297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42298   void * jresult ;
42299   Dali::TapGestureDetector result;
42300
42301   {
42302     try {
42303       result = Dali::TapGestureDetector::New();
42304     } catch (std::out_of_range& e) {
42305       {
42306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42307       };
42308     } catch (std::exception& e) {
42309       {
42310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42311       };
42312     } catch (Dali::DaliException e) {
42313       {
42314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42315       };
42316     } catch (...) {
42317       {
42318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42319       };
42320     }
42321   }
42322
42323   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42324   return jresult;
42325 }
42326
42327
42328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42329   void * jresult ;
42330   unsigned int arg1 ;
42331   Dali::TapGestureDetector result;
42332
42333   arg1 = (unsigned int)jarg1;
42334   {
42335     try {
42336       result = Dali::TapGestureDetector::New(arg1);
42337     } catch (std::out_of_range& e) {
42338       {
42339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42340       };
42341     } catch (std::exception& e) {
42342       {
42343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42344       };
42345     } catch (Dali::DaliException e) {
42346       {
42347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42348       };
42349     } catch (...) {
42350       {
42351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42352       };
42353     }
42354   }
42355
42356   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42357   return jresult;
42358 }
42359
42360
42361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42362   void * jresult ;
42363   Dali::BaseHandle arg1 ;
42364   Dali::BaseHandle *argp1 ;
42365   Dali::TapGestureDetector result;
42366
42367   argp1 = (Dali::BaseHandle *)jarg1;
42368   if (!argp1) {
42369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42370     return 0;
42371   }
42372   arg1 = *argp1;
42373   {
42374     try {
42375       result = Dali::TapGestureDetector::DownCast(arg1);
42376     } catch (std::out_of_range& e) {
42377       {
42378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42379       };
42380     } catch (std::exception& e) {
42381       {
42382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42383       };
42384     } catch (Dali::DaliException e) {
42385       {
42386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42387       };
42388     } catch (...) {
42389       {
42390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42391       };
42392     }
42393   }
42394
42395   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42396   return jresult;
42397 }
42398
42399
42400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42401   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42402
42403   arg1 = (Dali::TapGestureDetector *)jarg1;
42404   {
42405     try {
42406       delete arg1;
42407     } catch (std::out_of_range& e) {
42408       {
42409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42410       };
42411     } catch (std::exception& e) {
42412       {
42413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42414       };
42415     } catch (Dali::DaliException e) {
42416       {
42417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42418       };
42419     } catch (...) {
42420       {
42421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42422       };
42423     }
42424   }
42425
42426 }
42427
42428
42429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42430   void * jresult ;
42431   Dali::TapGestureDetector *arg1 = 0 ;
42432   Dali::TapGestureDetector *result = 0 ;
42433
42434   arg1 = (Dali::TapGestureDetector *)jarg1;
42435   if (!arg1) {
42436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42437     return 0;
42438   }
42439   {
42440     try {
42441       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42442     } catch (std::out_of_range& e) {
42443       {
42444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42445       };
42446     } catch (std::exception& e) {
42447       {
42448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42449       };
42450     } catch (Dali::DaliException e) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42453       };
42454     } catch (...) {
42455       {
42456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42457       };
42458     }
42459   }
42460
42461   jresult = (void *)result;
42462   return jresult;
42463 }
42464
42465
42466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42467   void * jresult ;
42468   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42469   Dali::TapGestureDetector *arg2 = 0 ;
42470   Dali::TapGestureDetector *result = 0 ;
42471
42472   arg1 = (Dali::TapGestureDetector *)jarg1;
42473   arg2 = (Dali::TapGestureDetector *)jarg2;
42474   if (!arg2) {
42475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42476     return 0;
42477   }
42478   {
42479     try {
42480       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42481     } catch (std::out_of_range& e) {
42482       {
42483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42484       };
42485     } catch (std::exception& e) {
42486       {
42487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42488       };
42489     } catch (Dali::DaliException e) {
42490       {
42491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42492       };
42493     } catch (...) {
42494       {
42495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42496       };
42497     }
42498   }
42499
42500   jresult = (void *)result;
42501   return jresult;
42502 }
42503
42504
42505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42506   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42507   unsigned int arg2 ;
42508
42509   arg1 = (Dali::TapGestureDetector *)jarg1;
42510   arg2 = (unsigned int)jarg2;
42511   {
42512     try {
42513       (arg1)->SetMinimumTapsRequired(arg2);
42514     } catch (std::out_of_range& e) {
42515       {
42516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42517       };
42518     } catch (std::exception& e) {
42519       {
42520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42521       };
42522     } catch (Dali::DaliException e) {
42523       {
42524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42525       };
42526     } catch (...) {
42527       {
42528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42529       };
42530     }
42531   }
42532
42533 }
42534
42535
42536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42537   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42538   unsigned int arg2 ;
42539
42540   arg1 = (Dali::TapGestureDetector *)jarg1;
42541   arg2 = (unsigned int)jarg2;
42542   {
42543     try {
42544       (arg1)->SetMaximumTapsRequired(arg2);
42545     } catch (std::out_of_range& e) {
42546       {
42547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42548       };
42549     } catch (std::exception& e) {
42550       {
42551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42552       };
42553     } catch (Dali::DaliException e) {
42554       {
42555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42556       };
42557     } catch (...) {
42558       {
42559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42560       };
42561     }
42562   }
42563
42564 }
42565
42566
42567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42568   unsigned int jresult ;
42569   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42570   unsigned int result;
42571
42572   arg1 = (Dali::TapGestureDetector *)jarg1;
42573   {
42574     try {
42575       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42576     } catch (std::out_of_range& e) {
42577       {
42578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42579       };
42580     } catch (std::exception& e) {
42581       {
42582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42583       };
42584     } catch (Dali::DaliException e) {
42585       {
42586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42587       };
42588     } catch (...) {
42589       {
42590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42591       };
42592     }
42593   }
42594
42595   jresult = result;
42596   return jresult;
42597 }
42598
42599
42600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42601   unsigned int jresult ;
42602   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42603   unsigned int result;
42604
42605   arg1 = (Dali::TapGestureDetector *)jarg1;
42606   {
42607     try {
42608       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42609     } catch (std::out_of_range& e) {
42610       {
42611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42612       };
42613     } catch (std::exception& e) {
42614       {
42615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42616       };
42617     } catch (Dali::DaliException e) {
42618       {
42619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42620       };
42621     } catch (...) {
42622       {
42623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42624       };
42625     }
42626   }
42627
42628   jresult = result;
42629   return jresult;
42630 }
42631
42632
42633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42634   void * jresult ;
42635   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42636   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42637
42638   arg1 = (Dali::TapGestureDetector *)jarg1;
42639   {
42640     try {
42641       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42642     } catch (std::out_of_range& e) {
42643       {
42644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42645       };
42646     } catch (std::exception& e) {
42647       {
42648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42649       };
42650     } catch (Dali::DaliException e) {
42651       {
42652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42653       };
42654     } catch (...) {
42655       {
42656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42657       };
42658     }
42659   }
42660
42661   jresult = (void *)result;
42662   return jresult;
42663 }
42664
42665
42666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42667   void * jresult ;
42668   Dali::TapGesture *result = 0 ;
42669
42670   {
42671     try {
42672       result = (Dali::TapGesture *)new Dali::TapGesture();
42673     } catch (std::out_of_range& e) {
42674       {
42675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42676       };
42677     } catch (std::exception& e) {
42678       {
42679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42680       };
42681     } catch (Dali::DaliException e) {
42682       {
42683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42684       };
42685     } catch (...) {
42686       {
42687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42688       };
42689     }
42690   }
42691
42692   jresult = (void *)result;
42693   return jresult;
42694 }
42695
42696
42697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42698   void * jresult ;
42699   Dali::TapGesture *arg1 = 0 ;
42700   Dali::TapGesture *result = 0 ;
42701
42702   arg1 = (Dali::TapGesture *)jarg1;
42703   if (!arg1) {
42704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42705     return 0;
42706   }
42707   {
42708     try {
42709       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42710     } catch (std::out_of_range& e) {
42711       {
42712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42713       };
42714     } catch (std::exception& e) {
42715       {
42716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42717       };
42718     } catch (Dali::DaliException e) {
42719       {
42720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42721       };
42722     } catch (...) {
42723       {
42724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42725       };
42726     }
42727   }
42728
42729   jresult = (void *)result;
42730   return jresult;
42731 }
42732
42733
42734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42735   void * jresult ;
42736   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42737   Dali::TapGesture *arg2 = 0 ;
42738   Dali::TapGesture *result = 0 ;
42739
42740   arg1 = (Dali::TapGesture *)jarg1;
42741   arg2 = (Dali::TapGesture *)jarg2;
42742   if (!arg2) {
42743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42744     return 0;
42745   }
42746   {
42747     try {
42748       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42749     } catch (std::out_of_range& e) {
42750       {
42751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42752       };
42753     } catch (std::exception& e) {
42754       {
42755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42756       };
42757     } catch (Dali::DaliException e) {
42758       {
42759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42760       };
42761     } catch (...) {
42762       {
42763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42764       };
42765     }
42766   }
42767
42768   jresult = (void *)result;
42769   return jresult;
42770 }
42771
42772
42773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42774   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42775
42776   arg1 = (Dali::TapGesture *)jarg1;
42777   {
42778     try {
42779       delete arg1;
42780     } catch (std::out_of_range& e) {
42781       {
42782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42783       };
42784     } catch (std::exception& e) {
42785       {
42786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42787       };
42788     } catch (Dali::DaliException e) {
42789       {
42790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42791       };
42792     } catch (...) {
42793       {
42794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42795       };
42796     }
42797   }
42798
42799 }
42800
42801
42802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42803   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42804   unsigned int arg2 ;
42805
42806   arg1 = (Dali::TapGesture *)jarg1;
42807   arg2 = (unsigned int)jarg2;
42808   if (arg1) (arg1)->numberOfTaps = arg2;
42809 }
42810
42811
42812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42813   unsigned int jresult ;
42814   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42815   unsigned int result;
42816
42817   arg1 = (Dali::TapGesture *)jarg1;
42818   result = (unsigned int) ((arg1)->numberOfTaps);
42819   jresult = result;
42820   return jresult;
42821 }
42822
42823
42824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42825   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42826   unsigned int arg2 ;
42827
42828   arg1 = (Dali::TapGesture *)jarg1;
42829   arg2 = (unsigned int)jarg2;
42830   if (arg1) (arg1)->numberOfTouches = arg2;
42831 }
42832
42833
42834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42835   unsigned int jresult ;
42836   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42837   unsigned int result;
42838
42839   arg1 = (Dali::TapGesture *)jarg1;
42840   result = (unsigned int) ((arg1)->numberOfTouches);
42841   jresult = result;
42842   return jresult;
42843 }
42844
42845
42846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42847   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42848   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42849
42850   arg1 = (Dali::TapGesture *)jarg1;
42851   arg2 = (Dali::Vector2 *)jarg2;
42852   if (arg1) (arg1)->screenPoint = *arg2;
42853 }
42854
42855
42856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42857   void * jresult ;
42858   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42859   Dali::Vector2 *result = 0 ;
42860
42861   arg1 = (Dali::TapGesture *)jarg1;
42862   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42863   jresult = (void *)result;
42864   return jresult;
42865 }
42866
42867
42868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42869   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42870   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42871
42872   arg1 = (Dali::TapGesture *)jarg1;
42873   arg2 = (Dali::Vector2 *)jarg2;
42874   if (arg1) (arg1)->localPoint = *arg2;
42875 }
42876
42877
42878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42879   void * jresult ;
42880   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42881   Dali::Vector2 *result = 0 ;
42882
42883   arg1 = (Dali::TapGesture *)jarg1;
42884   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42885   jresult = (void *)result;
42886   return jresult;
42887 }
42888
42889
42890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42891   void * jresult ;
42892   Dali::AlphaFunction *result = 0 ;
42893
42894   {
42895     try {
42896       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42897     } catch (std::out_of_range& e) {
42898       {
42899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42900       };
42901     } catch (std::exception& e) {
42902       {
42903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42904       };
42905     } catch (Dali::DaliException e) {
42906       {
42907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42908       };
42909     } catch (...) {
42910       {
42911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42912       };
42913     }
42914   }
42915
42916   jresult = (void *)result;
42917   return jresult;
42918 }
42919
42920
42921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42922   void * jresult ;
42923   Dali::AlphaFunction::BuiltinFunction arg1 ;
42924   Dali::AlphaFunction *result = 0 ;
42925
42926   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42927   {
42928     try {
42929       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42930     } catch (std::out_of_range& e) {
42931       {
42932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42933       };
42934     } catch (std::exception& e) {
42935       {
42936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42937       };
42938     } catch (Dali::DaliException e) {
42939       {
42940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42941       };
42942     } catch (...) {
42943       {
42944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42945       };
42946     }
42947   }
42948
42949   jresult = (void *)result;
42950   return jresult;
42951 }
42952
42953
42954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42955   void * jresult ;
42956   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42957   Dali::AlphaFunction *result = 0 ;
42958
42959   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42960   {
42961     try {
42962       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42963     } catch (std::out_of_range& e) {
42964       {
42965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42966       };
42967     } catch (std::exception& e) {
42968       {
42969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42970       };
42971     } catch (Dali::DaliException e) {
42972       {
42973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42974       };
42975     } catch (...) {
42976       {
42977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42978       };
42979     }
42980   }
42981
42982   jresult = (void *)result;
42983   return jresult;
42984 }
42985
42986
42987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42988   void * jresult ;
42989   Dali::Vector2 *arg1 = 0 ;
42990   Dali::Vector2 *arg2 = 0 ;
42991   Dali::AlphaFunction *result = 0 ;
42992
42993   arg1 = (Dali::Vector2 *)jarg1;
42994   if (!arg1) {
42995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42996     return 0;
42997   }
42998   arg2 = (Dali::Vector2 *)jarg2;
42999   if (!arg2) {
43000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43001     return 0;
43002   }
43003   {
43004     try {
43005       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43006     } catch (std::out_of_range& e) {
43007       {
43008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43009       };
43010     } catch (std::exception& e) {
43011       {
43012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43013       };
43014     } catch (Dali::DaliException e) {
43015       {
43016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43017       };
43018     } catch (...) {
43019       {
43020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43021       };
43022     }
43023   }
43024
43025   jresult = (void *)result;
43026   return jresult;
43027 }
43028
43029
43030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43031   void * jresult ;
43032   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43033   Dali::Vector4 result;
43034
43035   arg1 = (Dali::AlphaFunction *)jarg1;
43036   {
43037     try {
43038       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43039     } catch (std::out_of_range& e) {
43040       {
43041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43042       };
43043     } catch (std::exception& e) {
43044       {
43045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43046       };
43047     } catch (Dali::DaliException e) {
43048       {
43049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43050       };
43051     } catch (...) {
43052       {
43053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43054       };
43055     }
43056   }
43057
43058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43059   return jresult;
43060 }
43061
43062
43063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43064   void * jresult ;
43065   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43066   Dali::AlphaFunctionPrototype result;
43067
43068   arg1 = (Dali::AlphaFunction *)jarg1;
43069   {
43070     try {
43071       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43072     } catch (std::out_of_range& e) {
43073       {
43074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43075       };
43076     } catch (std::exception& e) {
43077       {
43078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43079       };
43080     } catch (Dali::DaliException e) {
43081       {
43082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43083       };
43084     } catch (...) {
43085       {
43086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43087       };
43088     }
43089   }
43090
43091   jresult = (void *)result;
43092   return jresult;
43093 }
43094
43095
43096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43097   int jresult ;
43098   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43099   Dali::AlphaFunction::BuiltinFunction result;
43100
43101   arg1 = (Dali::AlphaFunction *)jarg1;
43102   {
43103     try {
43104       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43105     } catch (std::out_of_range& e) {
43106       {
43107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43108       };
43109     } catch (std::exception& e) {
43110       {
43111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43112       };
43113     } catch (Dali::DaliException e) {
43114       {
43115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43116       };
43117     } catch (...) {
43118       {
43119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43120       };
43121     }
43122   }
43123
43124   jresult = (int)result;
43125   return jresult;
43126 }
43127
43128
43129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43130   int jresult ;
43131   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43132   Dali::AlphaFunction::Mode result;
43133
43134   arg1 = (Dali::AlphaFunction *)jarg1;
43135   {
43136     try {
43137       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43138     } catch (std::out_of_range& e) {
43139       {
43140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43141       };
43142     } catch (std::exception& e) {
43143       {
43144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43145       };
43146     } catch (Dali::DaliException e) {
43147       {
43148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43149       };
43150     } catch (...) {
43151       {
43152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43153       };
43154     }
43155   }
43156
43157   jresult = (int)result;
43158   return jresult;
43159 }
43160
43161
43162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43163   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43164
43165   arg1 = (Dali::AlphaFunction *)jarg1;
43166   {
43167     try {
43168       delete arg1;
43169     } catch (std::out_of_range& e) {
43170       {
43171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43172       };
43173     } catch (std::exception& e) {
43174       {
43175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43176       };
43177     } catch (Dali::DaliException e) {
43178       {
43179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43180       };
43181     } catch (...) {
43182       {
43183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43184       };
43185     }
43186   }
43187
43188 }
43189
43190
43191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43192   void * jresult ;
43193   Dali::KeyFrames result;
43194
43195   {
43196     try {
43197       result = Dali::KeyFrames::New();
43198     } catch (std::out_of_range& e) {
43199       {
43200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43201       };
43202     } catch (std::exception& e) {
43203       {
43204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43205       };
43206     } catch (Dali::DaliException e) {
43207       {
43208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43209       };
43210     } catch (...) {
43211       {
43212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43213       };
43214     }
43215   }
43216
43217   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43218   return jresult;
43219 }
43220
43221
43222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43223   void * jresult ;
43224   Dali::BaseHandle arg1 ;
43225   Dali::BaseHandle *argp1 ;
43226   Dali::KeyFrames result;
43227
43228   argp1 = (Dali::BaseHandle *)jarg1;
43229   if (!argp1) {
43230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43231     return 0;
43232   }
43233   arg1 = *argp1;
43234   {
43235     try {
43236       result = Dali::KeyFrames::DownCast(arg1);
43237     } catch (std::out_of_range& e) {
43238       {
43239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43240       };
43241     } catch (std::exception& e) {
43242       {
43243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43244       };
43245     } catch (Dali::DaliException e) {
43246       {
43247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43248       };
43249     } catch (...) {
43250       {
43251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43252       };
43253     }
43254   }
43255
43256   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43257   return jresult;
43258 }
43259
43260
43261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43262   void * jresult ;
43263   Dali::KeyFrames *result = 0 ;
43264
43265   {
43266     try {
43267       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43268     } catch (std::out_of_range& e) {
43269       {
43270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43271       };
43272     } catch (std::exception& e) {
43273       {
43274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43275       };
43276     } catch (Dali::DaliException e) {
43277       {
43278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43279       };
43280     } catch (...) {
43281       {
43282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43283       };
43284     }
43285   }
43286
43287   jresult = (void *)result;
43288   return jresult;
43289 }
43290
43291
43292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43293   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43294
43295   arg1 = (Dali::KeyFrames *)jarg1;
43296   {
43297     try {
43298       delete arg1;
43299     } catch (std::out_of_range& e) {
43300       {
43301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43302       };
43303     } catch (std::exception& e) {
43304       {
43305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43306       };
43307     } catch (Dali::DaliException e) {
43308       {
43309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43310       };
43311     } catch (...) {
43312       {
43313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43314       };
43315     }
43316   }
43317
43318 }
43319
43320
43321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43322   void * jresult ;
43323   Dali::KeyFrames *arg1 = 0 ;
43324   Dali::KeyFrames *result = 0 ;
43325
43326   arg1 = (Dali::KeyFrames *)jarg1;
43327   if (!arg1) {
43328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43329     return 0;
43330   }
43331   {
43332     try {
43333       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43334     } catch (std::out_of_range& e) {
43335       {
43336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43337       };
43338     } catch (std::exception& e) {
43339       {
43340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43341       };
43342     } catch (Dali::DaliException e) {
43343       {
43344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43345       };
43346     } catch (...) {
43347       {
43348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43349       };
43350     }
43351   }
43352
43353   jresult = (void *)result;
43354   return jresult;
43355 }
43356
43357
43358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43359   void * jresult ;
43360   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43361   Dali::KeyFrames *arg2 = 0 ;
43362   Dali::KeyFrames *result = 0 ;
43363
43364   arg1 = (Dali::KeyFrames *)jarg1;
43365   arg2 = (Dali::KeyFrames *)jarg2;
43366   if (!arg2) {
43367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43368     return 0;
43369   }
43370   {
43371     try {
43372       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43373     } catch (std::out_of_range& e) {
43374       {
43375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43376       };
43377     } catch (std::exception& e) {
43378       {
43379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43380       };
43381     } catch (Dali::DaliException e) {
43382       {
43383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43384       };
43385     } catch (...) {
43386       {
43387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43388       };
43389     }
43390   }
43391
43392   jresult = (void *)result;
43393   return jresult;
43394 }
43395
43396
43397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43398   int jresult ;
43399   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43400   Dali::Property::Type result;
43401
43402   arg1 = (Dali::KeyFrames *)jarg1;
43403   {
43404     try {
43405       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43406     } catch (std::out_of_range& e) {
43407       {
43408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43409       };
43410     } catch (std::exception& e) {
43411       {
43412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43413       };
43414     } catch (Dali::DaliException e) {
43415       {
43416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43417       };
43418     } catch (...) {
43419       {
43420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43421       };
43422     }
43423   }
43424
43425   jresult = (int)result;
43426   return jresult;
43427 }
43428
43429
43430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43431   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43432   float arg2 ;
43433   Dali::Property::Value arg3 ;
43434   Dali::Property::Value *argp3 ;
43435
43436   arg1 = (Dali::KeyFrames *)jarg1;
43437   arg2 = (float)jarg2;
43438   argp3 = (Dali::Property::Value *)jarg3;
43439   if (!argp3) {
43440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43441     return ;
43442   }
43443   arg3 = *argp3;
43444   {
43445     try {
43446       (arg1)->Add(arg2,arg3);
43447     } catch (std::out_of_range& e) {
43448       {
43449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43450       };
43451     } catch (std::exception& e) {
43452       {
43453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43454       };
43455     } catch (Dali::DaliException e) {
43456       {
43457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43458       };
43459     } catch (...) {
43460       {
43461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43462       };
43463     }
43464   }
43465
43466 }
43467
43468
43469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43470   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43471   float arg2 ;
43472   Dali::Property::Value arg3 ;
43473   Dali::AlphaFunction arg4 ;
43474   Dali::Property::Value *argp3 ;
43475   Dali::AlphaFunction *argp4 ;
43476
43477   arg1 = (Dali::KeyFrames *)jarg1;
43478   arg2 = (float)jarg2;
43479   argp3 = (Dali::Property::Value *)jarg3;
43480   if (!argp3) {
43481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43482     return ;
43483   }
43484   arg3 = *argp3;
43485   argp4 = (Dali::AlphaFunction *)jarg4;
43486   if (!argp4) {
43487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43488     return ;
43489   }
43490   arg4 = *argp4;
43491   {
43492     try {
43493       (arg1)->Add(arg2,arg3,arg4);
43494     } catch (std::out_of_range& e) {
43495       {
43496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43497       };
43498     } catch (std::exception& e) {
43499       {
43500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43501       };
43502     } catch (Dali::DaliException e) {
43503       {
43504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43505       };
43506     } catch (...) {
43507       {
43508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43509       };
43510     }
43511   }
43512
43513 }
43514
43515
43516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43517   int jresult ;
43518   int result;
43519
43520   result = (int)Dali::Path::Property::POINTS;
43521   jresult = (int)result;
43522   return jresult;
43523 }
43524
43525
43526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43527   int jresult ;
43528   int result;
43529
43530   result = (int)Dali::Path::Property::CONTROL_POINTS;
43531   jresult = (int)result;
43532   return jresult;
43533 }
43534
43535
43536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43537   void * jresult ;
43538   Dali::Path::Property *result = 0 ;
43539
43540   {
43541     try {
43542       result = (Dali::Path::Property *)new Dali::Path::Property();
43543     } catch (std::out_of_range& e) {
43544       {
43545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43546       };
43547     } catch (std::exception& e) {
43548       {
43549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43550       };
43551     } catch (Dali::DaliException e) {
43552       {
43553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43554       };
43555     } catch (...) {
43556       {
43557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43558       };
43559     }
43560   }
43561
43562   jresult = (void *)result;
43563   return jresult;
43564 }
43565
43566
43567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43568   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43569
43570   arg1 = (Dali::Path::Property *)jarg1;
43571   {
43572     try {
43573       delete arg1;
43574     } catch (std::out_of_range& e) {
43575       {
43576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43577       };
43578     } catch (std::exception& e) {
43579       {
43580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43581       };
43582     } catch (Dali::DaliException e) {
43583       {
43584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43585       };
43586     } catch (...) {
43587       {
43588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43589       };
43590     }
43591   }
43592
43593 }
43594
43595
43596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43597   void * jresult ;
43598   Dali::Path result;
43599
43600   {
43601     try {
43602       result = Dali::Path::New();
43603     } catch (std::out_of_range& e) {
43604       {
43605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43606       };
43607     } catch (std::exception& e) {
43608       {
43609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43610       };
43611     } catch (Dali::DaliException e) {
43612       {
43613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43614       };
43615     } catch (...) {
43616       {
43617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43618       };
43619     }
43620   }
43621
43622   jresult = new Dali::Path((const Dali::Path &)result);
43623   return jresult;
43624 }
43625
43626
43627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43628   void * jresult ;
43629   Dali::BaseHandle arg1 ;
43630   Dali::BaseHandle *argp1 ;
43631   Dali::Path result;
43632
43633   argp1 = (Dali::BaseHandle *)jarg1;
43634   if (!argp1) {
43635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43636     return 0;
43637   }
43638   arg1 = *argp1;
43639   {
43640     try {
43641       result = Dali::Path::DownCast(arg1);
43642     } catch (std::out_of_range& e) {
43643       {
43644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43645       };
43646     } catch (std::exception& e) {
43647       {
43648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43649       };
43650     } catch (Dali::DaliException e) {
43651       {
43652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43653       };
43654     } catch (...) {
43655       {
43656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43657       };
43658     }
43659   }
43660
43661   jresult = new Dali::Path((const Dali::Path &)result);
43662   return jresult;
43663 }
43664
43665
43666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43667   void * jresult ;
43668   Dali::Path *result = 0 ;
43669
43670   {
43671     try {
43672       result = (Dali::Path *)new Dali::Path();
43673     } catch (std::out_of_range& e) {
43674       {
43675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43676       };
43677     } catch (std::exception& e) {
43678       {
43679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43680       };
43681     } catch (Dali::DaliException e) {
43682       {
43683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43684       };
43685     } catch (...) {
43686       {
43687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43688       };
43689     }
43690   }
43691
43692   jresult = (void *)result;
43693   return jresult;
43694 }
43695
43696
43697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43698   Dali::Path *arg1 = (Dali::Path *) 0 ;
43699
43700   arg1 = (Dali::Path *)jarg1;
43701   {
43702     try {
43703       delete arg1;
43704     } catch (std::out_of_range& e) {
43705       {
43706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43707       };
43708     } catch (std::exception& e) {
43709       {
43710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43711       };
43712     } catch (Dali::DaliException e) {
43713       {
43714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43715       };
43716     } catch (...) {
43717       {
43718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43719       };
43720     }
43721   }
43722
43723 }
43724
43725
43726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43727   void * jresult ;
43728   Dali::Path *arg1 = 0 ;
43729   Dali::Path *result = 0 ;
43730
43731   arg1 = (Dali::Path *)jarg1;
43732   if (!arg1) {
43733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43734     return 0;
43735   }
43736   {
43737     try {
43738       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43739     } catch (std::out_of_range& e) {
43740       {
43741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43742       };
43743     } catch (std::exception& e) {
43744       {
43745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43746       };
43747     } catch (Dali::DaliException e) {
43748       {
43749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43750       };
43751     } catch (...) {
43752       {
43753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43754       };
43755     }
43756   }
43757
43758   jresult = (void *)result;
43759   return jresult;
43760 }
43761
43762
43763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43764   void * jresult ;
43765   Dali::Path *arg1 = (Dali::Path *) 0 ;
43766   Dali::Path *arg2 = 0 ;
43767   Dali::Path *result = 0 ;
43768
43769   arg1 = (Dali::Path *)jarg1;
43770   arg2 = (Dali::Path *)jarg2;
43771   if (!arg2) {
43772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43773     return 0;
43774   }
43775   {
43776     try {
43777       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43778     } catch (std::out_of_range& e) {
43779       {
43780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43781       };
43782     } catch (std::exception& e) {
43783       {
43784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43785       };
43786     } catch (Dali::DaliException e) {
43787       {
43788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43789       };
43790     } catch (...) {
43791       {
43792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43793       };
43794     }
43795   }
43796
43797   jresult = (void *)result;
43798   return jresult;
43799 }
43800
43801
43802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43803   Dali::Path *arg1 = (Dali::Path *) 0 ;
43804   Dali::Vector3 *arg2 = 0 ;
43805
43806   arg1 = (Dali::Path *)jarg1;
43807   arg2 = (Dali::Vector3 *)jarg2;
43808   if (!arg2) {
43809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43810     return ;
43811   }
43812   {
43813     try {
43814       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43815     } catch (std::out_of_range& e) {
43816       {
43817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43818       };
43819     } catch (std::exception& e) {
43820       {
43821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43822       };
43823     } catch (Dali::DaliException e) {
43824       {
43825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43826       };
43827     } catch (...) {
43828       {
43829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43830       };
43831     }
43832   }
43833
43834 }
43835
43836
43837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43838   Dali::Path *arg1 = (Dali::Path *) 0 ;
43839   Dali::Vector3 *arg2 = 0 ;
43840
43841   arg1 = (Dali::Path *)jarg1;
43842   arg2 = (Dali::Vector3 *)jarg2;
43843   if (!arg2) {
43844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43845     return ;
43846   }
43847   {
43848     try {
43849       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43850     } catch (std::out_of_range& e) {
43851       {
43852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43853       };
43854     } catch (std::exception& e) {
43855       {
43856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43857       };
43858     } catch (Dali::DaliException e) {
43859       {
43860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43861       };
43862     } catch (...) {
43863       {
43864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43865       };
43866     }
43867   }
43868
43869 }
43870
43871
43872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43873   Dali::Path *arg1 = (Dali::Path *) 0 ;
43874   float arg2 ;
43875
43876   arg1 = (Dali::Path *)jarg1;
43877   arg2 = (float)jarg2;
43878   {
43879     try {
43880       (arg1)->GenerateControlPoints(arg2);
43881     } catch (std::out_of_range& e) {
43882       {
43883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43884       };
43885     } catch (std::exception& e) {
43886       {
43887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43888       };
43889     } catch (Dali::DaliException e) {
43890       {
43891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43892       };
43893     } catch (...) {
43894       {
43895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43896       };
43897     }
43898   }
43899
43900 }
43901
43902
43903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43904   Dali::Path *arg1 = (Dali::Path *) 0 ;
43905   float arg2 ;
43906   Dali::Vector3 *arg3 = 0 ;
43907   Dali::Vector3 *arg4 = 0 ;
43908
43909   arg1 = (Dali::Path *)jarg1;
43910   arg2 = (float)jarg2;
43911   arg3 = (Dali::Vector3 *)jarg3;
43912   if (!arg3) {
43913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43914     return ;
43915   }
43916   arg4 = (Dali::Vector3 *)jarg4;
43917   if (!arg4) {
43918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43919     return ;
43920   }
43921   {
43922     try {
43923       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43924     } catch (std::out_of_range& e) {
43925       {
43926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43927       };
43928     } catch (std::exception& e) {
43929       {
43930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43931       };
43932     } catch (Dali::DaliException e) {
43933       {
43934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43935       };
43936     } catch (...) {
43937       {
43938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43939       };
43940     }
43941   }
43942
43943 }
43944
43945
43946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43947   void * jresult ;
43948   Dali::Path *arg1 = (Dali::Path *) 0 ;
43949   size_t arg2 ;
43950   Dali::Vector3 *result = 0 ;
43951
43952   arg1 = (Dali::Path *)jarg1;
43953   arg2 = (size_t)jarg2;
43954   {
43955     try {
43956       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43957     } catch (std::out_of_range& e) {
43958       {
43959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43960       };
43961     } catch (std::exception& e) {
43962       {
43963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43964       };
43965     } catch (Dali::DaliException e) {
43966       {
43967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43968       };
43969     } catch (...) {
43970       {
43971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43972       };
43973     }
43974   }
43975
43976   jresult = (void *)result;
43977   return jresult;
43978 }
43979
43980
43981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43982   void * jresult ;
43983   Dali::Path *arg1 = (Dali::Path *) 0 ;
43984   size_t arg2 ;
43985   Dali::Vector3 *result = 0 ;
43986
43987   arg1 = (Dali::Path *)jarg1;
43988   arg2 = (size_t)jarg2;
43989   {
43990     try {
43991       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43992     } catch (std::out_of_range& e) {
43993       {
43994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43995       };
43996     } catch (std::exception& e) {
43997       {
43998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43999       };
44000     } catch (Dali::DaliException e) {
44001       {
44002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44003       };
44004     } catch (...) {
44005       {
44006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44007       };
44008     }
44009   }
44010
44011   jresult = (void *)result;
44012   return jresult;
44013 }
44014
44015
44016 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44017   unsigned long jresult ;
44018   Dali::Path *arg1 = (Dali::Path *) 0 ;
44019   size_t result;
44020
44021   arg1 = (Dali::Path *)jarg1;
44022   {
44023     try {
44024       result = ((Dali::Path const *)arg1)->GetPointCount();
44025     } catch (std::out_of_range& e) {
44026       {
44027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44028       };
44029     } catch (std::exception& e) {
44030       {
44031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44032       };
44033     } catch (Dali::DaliException e) {
44034       {
44035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44036       };
44037     } catch (...) {
44038       {
44039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44040       };
44041     }
44042   }
44043
44044   jresult = (unsigned long)result;
44045   return jresult;
44046 }
44047
44048
44049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44050   void * jresult ;
44051   float arg1 ;
44052   Dali::TimePeriod *result = 0 ;
44053
44054   arg1 = (float)jarg1;
44055   {
44056     try {
44057       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44058     } catch (std::out_of_range& e) {
44059       {
44060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44061       };
44062     } catch (std::exception& e) {
44063       {
44064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44065       };
44066     } catch (Dali::DaliException e) {
44067       {
44068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44069       };
44070     } catch (...) {
44071       {
44072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44073       };
44074     }
44075   }
44076
44077   jresult = (void *)result;
44078   return jresult;
44079 }
44080
44081
44082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44083   void * jresult ;
44084   float arg1 ;
44085   float arg2 ;
44086   Dali::TimePeriod *result = 0 ;
44087
44088   arg1 = (float)jarg1;
44089   arg2 = (float)jarg2;
44090   {
44091     try {
44092       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44093     } catch (std::out_of_range& e) {
44094       {
44095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44096       };
44097     } catch (std::exception& e) {
44098       {
44099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44100       };
44101     } catch (Dali::DaliException e) {
44102       {
44103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44104       };
44105     } catch (...) {
44106       {
44107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44108       };
44109     }
44110   }
44111
44112   jresult = (void *)result;
44113   return jresult;
44114 }
44115
44116
44117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44118   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44119
44120   arg1 = (Dali::TimePeriod *)jarg1;
44121   {
44122     try {
44123       delete arg1;
44124     } catch (std::out_of_range& e) {
44125       {
44126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44127       };
44128     } catch (std::exception& e) {
44129       {
44130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44131       };
44132     } catch (Dali::DaliException e) {
44133       {
44134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44135       };
44136     } catch (...) {
44137       {
44138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44139       };
44140     }
44141   }
44142
44143 }
44144
44145
44146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44147   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44148   float arg2 ;
44149
44150   arg1 = (Dali::TimePeriod *)jarg1;
44151   arg2 = (float)jarg2;
44152   if (arg1) (arg1)->delaySeconds = arg2;
44153 }
44154
44155
44156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44157   float jresult ;
44158   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44159   float result;
44160
44161   arg1 = (Dali::TimePeriod *)jarg1;
44162   result = (float) ((arg1)->delaySeconds);
44163   jresult = result;
44164   return jresult;
44165 }
44166
44167
44168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44169   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44170   float arg2 ;
44171
44172   arg1 = (Dali::TimePeriod *)jarg1;
44173   arg2 = (float)jarg2;
44174   if (arg1) (arg1)->durationSeconds = arg2;
44175 }
44176
44177
44178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44179   float jresult ;
44180   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44181   float result;
44182
44183   arg1 = (Dali::TimePeriod *)jarg1;
44184   result = (float) ((arg1)->durationSeconds);
44185   jresult = result;
44186   return jresult;
44187 }
44188
44189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44190   int jresult ;
44191   int result;
44192
44193   result = (int)Dali::LinearConstrainer::Property::VALUE;
44194   jresult = (int)result;
44195   return jresult;
44196 }
44197
44198
44199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44200   int jresult ;
44201   int result;
44202
44203   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44204   jresult = (int)result;
44205   return jresult;
44206 }
44207
44208
44209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44210   void * jresult ;
44211   Dali::LinearConstrainer::Property *result = 0 ;
44212
44213   {
44214     try {
44215       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44216     } catch (std::out_of_range& e) {
44217       {
44218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44219       };
44220     } catch (std::exception& e) {
44221       {
44222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44223       };
44224     } catch (Dali::DaliException e) {
44225       {
44226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44227       };
44228     } catch (...) {
44229       {
44230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44231       };
44232     }
44233   }
44234
44235   jresult = (void *)result;
44236   return jresult;
44237 }
44238
44239
44240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44241   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44242
44243   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44244   {
44245     try {
44246       delete arg1;
44247     } catch (std::out_of_range& e) {
44248       {
44249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44250       };
44251     } catch (std::exception& e) {
44252       {
44253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44254       };
44255     } catch (Dali::DaliException e) {
44256       {
44257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44258       };
44259     } catch (...) {
44260       {
44261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44262       };
44263     }
44264   }
44265
44266 }
44267
44268
44269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44270   void * jresult ;
44271   Dali::LinearConstrainer result;
44272
44273   {
44274     try {
44275       result = Dali::LinearConstrainer::New();
44276     } catch (std::out_of_range& e) {
44277       {
44278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44279       };
44280     } catch (std::exception& e) {
44281       {
44282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44283       };
44284     } catch (Dali::DaliException e) {
44285       {
44286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44287       };
44288     } catch (...) {
44289       {
44290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44291       };
44292     }
44293   }
44294
44295   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44296   return jresult;
44297 }
44298
44299
44300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44301   void * jresult ;
44302   Dali::BaseHandle arg1 ;
44303   Dali::BaseHandle *argp1 ;
44304   Dali::LinearConstrainer result;
44305
44306   argp1 = (Dali::BaseHandle *)jarg1;
44307   if (!argp1) {
44308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44309     return 0;
44310   }
44311   arg1 = *argp1;
44312   {
44313     try {
44314       result = Dali::LinearConstrainer::DownCast(arg1);
44315     } catch (std::out_of_range& e) {
44316       {
44317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44318       };
44319     } catch (std::exception& e) {
44320       {
44321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44322       };
44323     } catch (Dali::DaliException e) {
44324       {
44325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44326       };
44327     } catch (...) {
44328       {
44329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44330       };
44331     }
44332   }
44333
44334   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44335   return jresult;
44336 }
44337
44338
44339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44340   void * jresult ;
44341   Dali::LinearConstrainer *result = 0 ;
44342
44343   {
44344     try {
44345       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44346     } catch (std::out_of_range& e) {
44347       {
44348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44349       };
44350     } catch (std::exception& e) {
44351       {
44352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44353       };
44354     } catch (Dali::DaliException e) {
44355       {
44356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44357       };
44358     } catch (...) {
44359       {
44360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44361       };
44362     }
44363   }
44364
44365   jresult = (void *)result;
44366   return jresult;
44367 }
44368
44369
44370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44371   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44372
44373   arg1 = (Dali::LinearConstrainer *)jarg1;
44374   {
44375     try {
44376       delete arg1;
44377     } catch (std::out_of_range& e) {
44378       {
44379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44380       };
44381     } catch (std::exception& e) {
44382       {
44383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44384       };
44385     } catch (Dali::DaliException e) {
44386       {
44387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44388       };
44389     } catch (...) {
44390       {
44391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44392       };
44393     }
44394   }
44395
44396 }
44397
44398
44399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44400   void * jresult ;
44401   Dali::LinearConstrainer *arg1 = 0 ;
44402   Dali::LinearConstrainer *result = 0 ;
44403
44404   arg1 = (Dali::LinearConstrainer *)jarg1;
44405   if (!arg1) {
44406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44407     return 0;
44408   }
44409   {
44410     try {
44411       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44412     } catch (std::out_of_range& e) {
44413       {
44414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44415       };
44416     } catch (std::exception& e) {
44417       {
44418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44419       };
44420     } catch (Dali::DaliException e) {
44421       {
44422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44423       };
44424     } catch (...) {
44425       {
44426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44427       };
44428     }
44429   }
44430
44431   jresult = (void *)result;
44432   return jresult;
44433 }
44434
44435
44436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44437   void * jresult ;
44438   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44439   Dali::LinearConstrainer *arg2 = 0 ;
44440   Dali::LinearConstrainer *result = 0 ;
44441
44442   arg1 = (Dali::LinearConstrainer *)jarg1;
44443   arg2 = (Dali::LinearConstrainer *)jarg2;
44444   if (!arg2) {
44445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44446     return 0;
44447   }
44448   {
44449     try {
44450       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44451     } catch (std::out_of_range& e) {
44452       {
44453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44454       };
44455     } catch (std::exception& e) {
44456       {
44457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44458       };
44459     } catch (Dali::DaliException e) {
44460       {
44461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44462       };
44463     } catch (...) {
44464       {
44465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44466       };
44467     }
44468   }
44469
44470   jresult = (void *)result;
44471   return jresult;
44472 }
44473
44474
44475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44476   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44477   SwigValueWrapper< Dali::Property > arg2 ;
44478   SwigValueWrapper< Dali::Property > arg3 ;
44479   Dali::Vector2 *arg4 = 0 ;
44480   Dali::Vector2 *arg5 = 0 ;
44481   Dali::Property *argp2 ;
44482   Dali::Property *argp3 ;
44483
44484   arg1 = (Dali::LinearConstrainer *)jarg1;
44485   argp2 = (Dali::Property *)jarg2;
44486   if (!argp2) {
44487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44488     return ;
44489   }
44490   arg2 = *argp2;
44491   argp3 = (Dali::Property *)jarg3;
44492   if (!argp3) {
44493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44494     return ;
44495   }
44496   arg3 = *argp3;
44497   arg4 = (Dali::Vector2 *)jarg4;
44498   if (!arg4) {
44499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44500     return ;
44501   }
44502   arg5 = (Dali::Vector2 *)jarg5;
44503   if (!arg5) {
44504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44505     return ;
44506   }
44507   {
44508     try {
44509       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44510     } catch (std::out_of_range& e) {
44511       {
44512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44513       };
44514     } catch (std::exception& e) {
44515       {
44516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44517       };
44518     } catch (Dali::DaliException e) {
44519       {
44520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44521       };
44522     } catch (...) {
44523       {
44524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44525       };
44526     }
44527   }
44528
44529 }
44530
44531
44532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44533   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44534   SwigValueWrapper< Dali::Property > arg2 ;
44535   SwigValueWrapper< Dali::Property > arg3 ;
44536   Dali::Vector2 *arg4 = 0 ;
44537   Dali::Property *argp2 ;
44538   Dali::Property *argp3 ;
44539
44540   arg1 = (Dali::LinearConstrainer *)jarg1;
44541   argp2 = (Dali::Property *)jarg2;
44542   if (!argp2) {
44543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44544     return ;
44545   }
44546   arg2 = *argp2;
44547   argp3 = (Dali::Property *)jarg3;
44548   if (!argp3) {
44549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44550     return ;
44551   }
44552   arg3 = *argp3;
44553   arg4 = (Dali::Vector2 *)jarg4;
44554   if (!arg4) {
44555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44556     return ;
44557   }
44558   {
44559     try {
44560       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44561     } catch (std::out_of_range& e) {
44562       {
44563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44564       };
44565     } catch (std::exception& e) {
44566       {
44567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44568       };
44569     } catch (Dali::DaliException e) {
44570       {
44571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44572       };
44573     } catch (...) {
44574       {
44575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44576       };
44577     }
44578   }
44579
44580 }
44581
44582
44583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44584   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44585   Dali::Handle *arg2 = 0 ;
44586
44587   arg1 = (Dali::LinearConstrainer *)jarg1;
44588   arg2 = (Dali::Handle *)jarg2;
44589   if (!arg2) {
44590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44591     return ;
44592   }
44593   {
44594     try {
44595       (arg1)->Remove(*arg2);
44596     } catch (std::out_of_range& e) {
44597       {
44598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44599       };
44600     } catch (std::exception& e) {
44601       {
44602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44603       };
44604     } catch (Dali::DaliException e) {
44605       {
44606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44607       };
44608     } catch (...) {
44609       {
44610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44611       };
44612     }
44613   }
44614
44615 }
44616
44617
44618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44619   int jresult ;
44620   int result;
44621
44622   result = (int)Dali::PathConstrainer::Property::FORWARD;
44623   jresult = (int)result;
44624   return jresult;
44625 }
44626
44627
44628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44629   int jresult ;
44630   int result;
44631
44632   result = (int)Dali::PathConstrainer::Property::POINTS;
44633   jresult = (int)result;
44634   return jresult;
44635 }
44636
44637
44638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44639   int jresult ;
44640   int result;
44641
44642   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44643   jresult = (int)result;
44644   return jresult;
44645 }
44646
44647
44648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44649   void * jresult ;
44650   Dali::PathConstrainer::Property *result = 0 ;
44651
44652   {
44653     try {
44654       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44655     } catch (std::out_of_range& e) {
44656       {
44657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44658       };
44659     } catch (std::exception& e) {
44660       {
44661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44662       };
44663     } catch (Dali::DaliException e) {
44664       {
44665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44666       };
44667     } catch (...) {
44668       {
44669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44670       };
44671     }
44672   }
44673
44674   jresult = (void *)result;
44675   return jresult;
44676 }
44677
44678
44679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44680   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44681
44682   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44683   {
44684     try {
44685       delete arg1;
44686     } catch (std::out_of_range& e) {
44687       {
44688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44689       };
44690     } catch (std::exception& e) {
44691       {
44692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44693       };
44694     } catch (Dali::DaliException e) {
44695       {
44696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44697       };
44698     } catch (...) {
44699       {
44700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44701       };
44702     }
44703   }
44704
44705 }
44706
44707
44708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44709   void * jresult ;
44710   Dali::PathConstrainer result;
44711
44712   {
44713     try {
44714       result = Dali::PathConstrainer::New();
44715     } catch (std::out_of_range& e) {
44716       {
44717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44718       };
44719     } catch (std::exception& e) {
44720       {
44721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44722       };
44723     } catch (Dali::DaliException e) {
44724       {
44725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44726       };
44727     } catch (...) {
44728       {
44729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44730       };
44731     }
44732   }
44733
44734   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44735   return jresult;
44736 }
44737
44738
44739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44740   void * jresult ;
44741   Dali::BaseHandle arg1 ;
44742   Dali::BaseHandle *argp1 ;
44743   Dali::PathConstrainer result;
44744
44745   argp1 = (Dali::BaseHandle *)jarg1;
44746   if (!argp1) {
44747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44748     return 0;
44749   }
44750   arg1 = *argp1;
44751   {
44752     try {
44753       result = Dali::PathConstrainer::DownCast(arg1);
44754     } catch (std::out_of_range& e) {
44755       {
44756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44757       };
44758     } catch (std::exception& e) {
44759       {
44760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44761       };
44762     } catch (Dali::DaliException e) {
44763       {
44764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44765       };
44766     } catch (...) {
44767       {
44768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44769       };
44770     }
44771   }
44772
44773   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44774   return jresult;
44775 }
44776
44777
44778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44779   void * jresult ;
44780   Dali::PathConstrainer *result = 0 ;
44781
44782   {
44783     try {
44784       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44785     } catch (std::out_of_range& e) {
44786       {
44787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44788       };
44789     } catch (std::exception& e) {
44790       {
44791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44792       };
44793     } catch (Dali::DaliException e) {
44794       {
44795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44796       };
44797     } catch (...) {
44798       {
44799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44800       };
44801     }
44802   }
44803
44804   jresult = (void *)result;
44805   return jresult;
44806 }
44807
44808
44809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44810   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44811
44812   arg1 = (Dali::PathConstrainer *)jarg1;
44813   {
44814     try {
44815       delete arg1;
44816     } catch (std::out_of_range& e) {
44817       {
44818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44819       };
44820     } catch (std::exception& e) {
44821       {
44822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44823       };
44824     } catch (Dali::DaliException e) {
44825       {
44826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44827       };
44828     } catch (...) {
44829       {
44830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44831       };
44832     }
44833   }
44834
44835 }
44836
44837
44838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44839   void * jresult ;
44840   Dali::PathConstrainer *arg1 = 0 ;
44841   Dali::PathConstrainer *result = 0 ;
44842
44843   arg1 = (Dali::PathConstrainer *)jarg1;
44844   if (!arg1) {
44845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44846     return 0;
44847   }
44848   {
44849     try {
44850       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44851     } catch (std::out_of_range& e) {
44852       {
44853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44854       };
44855     } catch (std::exception& e) {
44856       {
44857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44858       };
44859     } catch (Dali::DaliException e) {
44860       {
44861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44862       };
44863     } catch (...) {
44864       {
44865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44866       };
44867     }
44868   }
44869
44870   jresult = (void *)result;
44871   return jresult;
44872 }
44873
44874
44875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44876   void * jresult ;
44877   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44878   Dali::PathConstrainer *arg2 = 0 ;
44879   Dali::PathConstrainer *result = 0 ;
44880
44881   arg1 = (Dali::PathConstrainer *)jarg1;
44882   arg2 = (Dali::PathConstrainer *)jarg2;
44883   if (!arg2) {
44884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44885     return 0;
44886   }
44887   {
44888     try {
44889       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44890     } catch (std::out_of_range& e) {
44891       {
44892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44893       };
44894     } catch (std::exception& e) {
44895       {
44896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44897       };
44898     } catch (Dali::DaliException e) {
44899       {
44900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44901       };
44902     } catch (...) {
44903       {
44904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44905       };
44906     }
44907   }
44908
44909   jresult = (void *)result;
44910   return jresult;
44911 }
44912
44913
44914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44915   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44916   SwigValueWrapper< Dali::Property > arg2 ;
44917   SwigValueWrapper< Dali::Property > arg3 ;
44918   Dali::Vector2 *arg4 = 0 ;
44919   Dali::Vector2 *arg5 = 0 ;
44920   Dali::Property *argp2 ;
44921   Dali::Property *argp3 ;
44922
44923   arg1 = (Dali::PathConstrainer *)jarg1;
44924   argp2 = (Dali::Property *)jarg2;
44925   if (!argp2) {
44926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44927     return ;
44928   }
44929   arg2 = *argp2;
44930   argp3 = (Dali::Property *)jarg3;
44931   if (!argp3) {
44932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44933     return ;
44934   }
44935   arg3 = *argp3;
44936   arg4 = (Dali::Vector2 *)jarg4;
44937   if (!arg4) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44939     return ;
44940   }
44941   arg5 = (Dali::Vector2 *)jarg5;
44942   if (!arg5) {
44943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44944     return ;
44945   }
44946   {
44947     try {
44948       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44949     } catch (std::out_of_range& e) {
44950       {
44951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (std::exception& e) {
44954       {
44955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44956       };
44957     } catch (Dali::DaliException e) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44960       };
44961     } catch (...) {
44962       {
44963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44964       };
44965     }
44966   }
44967
44968 }
44969
44970
44971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44972   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44973   SwigValueWrapper< Dali::Property > arg2 ;
44974   SwigValueWrapper< Dali::Property > arg3 ;
44975   Dali::Vector2 *arg4 = 0 ;
44976   Dali::Property *argp2 ;
44977   Dali::Property *argp3 ;
44978
44979   arg1 = (Dali::PathConstrainer *)jarg1;
44980   argp2 = (Dali::Property *)jarg2;
44981   if (!argp2) {
44982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44983     return ;
44984   }
44985   arg2 = *argp2;
44986   argp3 = (Dali::Property *)jarg3;
44987   if (!argp3) {
44988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44989     return ;
44990   }
44991   arg3 = *argp3;
44992   arg4 = (Dali::Vector2 *)jarg4;
44993   if (!arg4) {
44994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44995     return ;
44996   }
44997   {
44998     try {
44999       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45000     } catch (std::out_of_range& e) {
45001       {
45002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45003       };
45004     } catch (std::exception& e) {
45005       {
45006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45007       };
45008     } catch (Dali::DaliException e) {
45009       {
45010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45011       };
45012     } catch (...) {
45013       {
45014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45015       };
45016     }
45017   }
45018
45019 }
45020
45021
45022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45023   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45024   Dali::Handle *arg2 = 0 ;
45025
45026   arg1 = (Dali::PathConstrainer *)jarg1;
45027   arg2 = (Dali::Handle *)jarg2;
45028   if (!arg2) {
45029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45030     return ;
45031   }
45032   {
45033     try {
45034       (arg1)->Remove(*arg2);
45035     } catch (std::out_of_range& e) {
45036       {
45037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45038       };
45039     } catch (std::exception& e) {
45040       {
45041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45042       };
45043     } catch (Dali::DaliException e) {
45044       {
45045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45046       };
45047     } catch (...) {
45048       {
45049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45050       };
45051     }
45052   }
45053
45054 }
45055
45056
45057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45058   int jresult ;
45059   Dali::FittingMode::Type result;
45060
45061   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45062   jresult = (int)result;
45063   return jresult;
45064 }
45065
45066
45067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45068   int jresult ;
45069   Dali::SamplingMode::Type result;
45070
45071   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45072   jresult = (int)result;
45073   return jresult;
45074 }
45075
45076
45077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45078   void * jresult ;
45079   Dali::BufferImage *result = 0 ;
45080
45081   {
45082     try {
45083       result = (Dali::BufferImage *)new Dali::BufferImage();
45084     } catch (std::out_of_range& e) {
45085       {
45086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45087       };
45088     } catch (std::exception& e) {
45089       {
45090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45091       };
45092     } catch (Dali::DaliException e) {
45093       {
45094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45095       };
45096     } catch (...) {
45097       {
45098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45099       };
45100     }
45101   }
45102
45103   jresult = (void *)result;
45104   return jresult;
45105 }
45106
45107
45108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45109   void * jresult ;
45110   unsigned int arg1 ;
45111   unsigned int arg2 ;
45112   Dali::Pixel::Format arg3 ;
45113   Dali::BufferImage result;
45114
45115   arg1 = (unsigned int)jarg1;
45116   arg2 = (unsigned int)jarg2;
45117   arg3 = (Dali::Pixel::Format)jarg3;
45118   {
45119     try {
45120       result = Dali::BufferImage::New(arg1,arg2,arg3);
45121     } catch (std::out_of_range& e) {
45122       {
45123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45124       };
45125     } catch (std::exception& e) {
45126       {
45127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45128       };
45129     } catch (Dali::DaliException e) {
45130       {
45131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45132       };
45133     } catch (...) {
45134       {
45135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45136       };
45137     }
45138   }
45139
45140   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45141   return jresult;
45142 }
45143
45144
45145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45146   void * jresult ;
45147   unsigned int arg1 ;
45148   unsigned int arg2 ;
45149   Dali::BufferImage result;
45150
45151   arg1 = (unsigned int)jarg1;
45152   arg2 = (unsigned int)jarg2;
45153   {
45154     try {
45155       result = Dali::BufferImage::New(arg1,arg2);
45156     } catch (std::out_of_range& e) {
45157       {
45158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45159       };
45160     } catch (std::exception& e) {
45161       {
45162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45163       };
45164     } catch (Dali::DaliException e) {
45165       {
45166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45167       };
45168     } catch (...) {
45169       {
45170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45171       };
45172     }
45173   }
45174
45175   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45176   return jresult;
45177 }
45178
45179
45180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45181   void * jresult ;
45182   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45183   unsigned int arg2 ;
45184   unsigned int arg3 ;
45185   Dali::Pixel::Format arg4 ;
45186   unsigned int arg5 ;
45187   Dali::BufferImage result;
45188
45189   arg1 = jarg1;
45190   arg2 = (unsigned int)jarg2;
45191   arg3 = (unsigned int)jarg3;
45192   arg4 = (Dali::Pixel::Format)jarg4;
45193   arg5 = (unsigned int)jarg5;
45194   {
45195     try {
45196       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45197     } catch (std::out_of_range& e) {
45198       {
45199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45200       };
45201     } catch (std::exception& e) {
45202       {
45203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45204       };
45205     } catch (Dali::DaliException e) {
45206       {
45207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45208       };
45209     } catch (...) {
45210       {
45211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45212       };
45213     }
45214   }
45215
45216   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45217
45218
45219   return jresult;
45220 }
45221
45222
45223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45224   void * jresult ;
45225   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45226   unsigned int arg2 ;
45227   unsigned int arg3 ;
45228   Dali::Pixel::Format arg4 ;
45229   Dali::BufferImage result;
45230
45231   arg1 = jarg1;
45232   arg2 = (unsigned int)jarg2;
45233   arg3 = (unsigned int)jarg3;
45234   arg4 = (Dali::Pixel::Format)jarg4;
45235   {
45236     try {
45237       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45238     } catch (std::out_of_range& e) {
45239       {
45240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45241       };
45242     } catch (std::exception& e) {
45243       {
45244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45245       };
45246     } catch (Dali::DaliException e) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45249       };
45250     } catch (...) {
45251       {
45252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45253       };
45254     }
45255   }
45256
45257   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45258
45259
45260   return jresult;
45261 }
45262
45263
45264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45265   void * jresult ;
45266   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45267   unsigned int arg2 ;
45268   unsigned int arg3 ;
45269   Dali::BufferImage result;
45270
45271   arg1 = jarg1;
45272   arg2 = (unsigned int)jarg2;
45273   arg3 = (unsigned int)jarg3;
45274   {
45275     try {
45276       result = Dali::BufferImage::New(arg1,arg2,arg3);
45277     } catch (std::out_of_range& e) {
45278       {
45279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45280       };
45281     } catch (std::exception& e) {
45282       {
45283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45284       };
45285     } catch (Dali::DaliException e) {
45286       {
45287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45288       };
45289     } catch (...) {
45290       {
45291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45292       };
45293     }
45294   }
45295
45296   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45297
45298
45299   return jresult;
45300 }
45301
45302
45303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45304   void * jresult ;
45305   Dali::BaseHandle arg1 ;
45306   Dali::BaseHandle *argp1 ;
45307   Dali::BufferImage result;
45308
45309   argp1 = (Dali::BaseHandle *)jarg1;
45310   if (!argp1) {
45311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45312     return 0;
45313   }
45314   arg1 = *argp1;
45315   {
45316     try {
45317       result = Dali::BufferImage::DownCast(arg1);
45318     } catch (std::out_of_range& e) {
45319       {
45320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45321       };
45322     } catch (std::exception& e) {
45323       {
45324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45325       };
45326     } catch (Dali::DaliException e) {
45327       {
45328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45329       };
45330     } catch (...) {
45331       {
45332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45333       };
45334     }
45335   }
45336
45337   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45338   return jresult;
45339 }
45340
45341
45342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45343   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45344
45345   arg1 = (Dali::BufferImage *)jarg1;
45346   {
45347     try {
45348       delete arg1;
45349     } catch (std::out_of_range& e) {
45350       {
45351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45352       };
45353     } catch (std::exception& e) {
45354       {
45355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45356       };
45357     } catch (Dali::DaliException e) {
45358       {
45359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45360       };
45361     } catch (...) {
45362       {
45363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45364       };
45365     }
45366   }
45367
45368 }
45369
45370
45371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45372   void * jresult ;
45373   Dali::BufferImage *arg1 = 0 ;
45374   Dali::BufferImage *result = 0 ;
45375
45376   arg1 = (Dali::BufferImage *)jarg1;
45377   if (!arg1) {
45378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45379     return 0;
45380   }
45381   {
45382     try {
45383       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45384     } catch (std::out_of_range& e) {
45385       {
45386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45387       };
45388     } catch (std::exception& e) {
45389       {
45390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45391       };
45392     } catch (Dali::DaliException e) {
45393       {
45394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45395       };
45396     } catch (...) {
45397       {
45398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45399       };
45400     }
45401   }
45402
45403   jresult = (void *)result;
45404   return jresult;
45405 }
45406
45407
45408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45409   void * jresult ;
45410   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45411   Dali::BufferImage *arg2 = 0 ;
45412   Dali::BufferImage *result = 0 ;
45413
45414   arg1 = (Dali::BufferImage *)jarg1;
45415   arg2 = (Dali::BufferImage *)jarg2;
45416   if (!arg2) {
45417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45418     return 0;
45419   }
45420   {
45421     try {
45422       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45423     } catch (std::out_of_range& e) {
45424       {
45425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45426       };
45427     } catch (std::exception& e) {
45428       {
45429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45430       };
45431     } catch (Dali::DaliException e) {
45432       {
45433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45434       };
45435     } catch (...) {
45436       {
45437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45438       };
45439     }
45440   }
45441
45442   jresult = (void *)result;
45443   return jresult;
45444 }
45445
45446
45447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45448   void * jresult ;
45449   Dali::BufferImage result;
45450
45451   {
45452     try {
45453       result = Dali::BufferImage::WHITE();
45454     } catch (std::out_of_range& e) {
45455       {
45456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45457       };
45458     } catch (std::exception& e) {
45459       {
45460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45461       };
45462     } catch (Dali::DaliException e) {
45463       {
45464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45465       };
45466     } catch (...) {
45467       {
45468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45469       };
45470     }
45471   }
45472
45473   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45474   return jresult;
45475 }
45476
45477
45478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45479   void * jresult ;
45480   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45481   Dali::PixelBuffer *result = 0 ;
45482
45483   arg1 = (Dali::BufferImage *)jarg1;
45484   {
45485     try {
45486       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45487     } catch (std::out_of_range& e) {
45488       {
45489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45490       };
45491     } catch (std::exception& e) {
45492       {
45493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45494       };
45495     } catch (Dali::DaliException e) {
45496       {
45497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45498       };
45499     } catch (...) {
45500       {
45501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45502       };
45503     }
45504   }
45505
45506   jresult = (void *)result;
45507   return jresult;
45508 }
45509
45510
45511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45512   unsigned int jresult ;
45513   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45514   unsigned int result;
45515
45516   arg1 = (Dali::BufferImage *)jarg1;
45517   {
45518     try {
45519       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45520     } catch (std::out_of_range& e) {
45521       {
45522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45523       };
45524     } catch (std::exception& e) {
45525       {
45526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45527       };
45528     } catch (Dali::DaliException e) {
45529       {
45530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45531       };
45532     } catch (...) {
45533       {
45534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45535       };
45536     }
45537   }
45538
45539   jresult = result;
45540   return jresult;
45541 }
45542
45543
45544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45545   unsigned int jresult ;
45546   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45547   unsigned int result;
45548
45549   arg1 = (Dali::BufferImage *)jarg1;
45550   {
45551     try {
45552       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45553     } catch (std::out_of_range& e) {
45554       {
45555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45556       };
45557     } catch (std::exception& e) {
45558       {
45559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45560       };
45561     } catch (Dali::DaliException e) {
45562       {
45563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45564       };
45565     } catch (...) {
45566       {
45567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45568       };
45569     }
45570   }
45571
45572   jresult = result;
45573   return jresult;
45574 }
45575
45576
45577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45578   int jresult ;
45579   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45580   Dali::Pixel::Format result;
45581
45582   arg1 = (Dali::BufferImage *)jarg1;
45583   {
45584     try {
45585       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45586     } catch (std::out_of_range& e) {
45587       {
45588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45589       };
45590     } catch (std::exception& e) {
45591       {
45592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45593       };
45594     } catch (Dali::DaliException e) {
45595       {
45596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45597       };
45598     } catch (...) {
45599       {
45600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45601       };
45602     }
45603   }
45604
45605   jresult = (int)result;
45606   return jresult;
45607 }
45608
45609
45610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45611   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45612
45613   arg1 = (Dali::BufferImage *)jarg1;
45614   {
45615     try {
45616       (arg1)->Update();
45617     } catch (std::out_of_range& e) {
45618       {
45619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45620       };
45621     } catch (std::exception& e) {
45622       {
45623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45624       };
45625     } catch (Dali::DaliException e) {
45626       {
45627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45628       };
45629     } catch (...) {
45630       {
45631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45632       };
45633     }
45634   }
45635
45636 }
45637
45638
45639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45640   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45641   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45642   Dali::RectArea *argp2 ;
45643
45644   arg1 = (Dali::BufferImage *)jarg1;
45645   argp2 = (Dali::RectArea *)jarg2;
45646   if (!argp2) {
45647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45648     return ;
45649   }
45650   arg2 = *argp2;
45651   {
45652     try {
45653       (arg1)->Update(arg2);
45654     } catch (std::out_of_range& e) {
45655       {
45656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45657       };
45658     } catch (std::exception& e) {
45659       {
45660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45661       };
45662     } catch (Dali::DaliException e) {
45663       {
45664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45665       };
45666     } catch (...) {
45667       {
45668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45669       };
45670     }
45671   }
45672
45673 }
45674
45675
45676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45677   unsigned int jresult ;
45678   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45679   bool result;
45680
45681   arg1 = (Dali::BufferImage *)jarg1;
45682   {
45683     try {
45684       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45685     } catch (std::out_of_range& e) {
45686       {
45687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45688       };
45689     } catch (std::exception& e) {
45690       {
45691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45692       };
45693     } catch (Dali::DaliException e) {
45694       {
45695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45696       };
45697     } catch (...) {
45698       {
45699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45700       };
45701     }
45702   }
45703
45704   jresult = result;
45705   return jresult;
45706 }
45707
45708
45709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45710   void * jresult ;
45711   Dali::EncodedBufferImage *result = 0 ;
45712
45713   {
45714     try {
45715       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45716     } catch (std::out_of_range& e) {
45717       {
45718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45719       };
45720     } catch (std::exception& e) {
45721       {
45722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45723       };
45724     } catch (Dali::DaliException e) {
45725       {
45726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45727       };
45728     } catch (...) {
45729       {
45730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45731       };
45732     }
45733   }
45734
45735   jresult = (void *)result;
45736   return jresult;
45737 }
45738
45739
45740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45741   void * jresult ;
45742   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45743   std::size_t arg2 ;
45744   Dali::EncodedBufferImage result;
45745
45746   arg1 = (uint8_t *)jarg1;
45747   arg2 = (std::size_t)jarg2;
45748   {
45749     try {
45750       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45751     } catch (std::out_of_range& e) {
45752       {
45753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45754       };
45755     } catch (std::exception& e) {
45756       {
45757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45758       };
45759     } catch (Dali::DaliException e) {
45760       {
45761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45762       };
45763     } catch (...) {
45764       {
45765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45766       };
45767     }
45768   }
45769
45770   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45771   return jresult;
45772 }
45773
45774
45775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45776   void * jresult ;
45777   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45778   std::size_t arg2 ;
45779   Dali::ImageDimensions arg3 ;
45780   Dali::FittingMode::Type arg4 ;
45781   Dali::SamplingMode::Type arg5 ;
45782   bool arg6 ;
45783   Dali::ImageDimensions *argp3 ;
45784   Dali::EncodedBufferImage result;
45785
45786   arg1 = (uint8_t *)jarg1;
45787   arg2 = (std::size_t)jarg2;
45788   argp3 = (Dali::ImageDimensions *)jarg3;
45789   if (!argp3) {
45790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45791     return 0;
45792   }
45793   arg3 = *argp3;
45794   arg4 = (Dali::FittingMode::Type)jarg4;
45795   arg5 = (Dali::SamplingMode::Type)jarg5;
45796   arg6 = jarg6 ? true : false;
45797   {
45798     try {
45799       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45800     } catch (std::out_of_range& e) {
45801       {
45802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45803       };
45804     } catch (std::exception& e) {
45805       {
45806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45807       };
45808     } catch (Dali::DaliException e) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45811       };
45812     } catch (...) {
45813       {
45814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45815       };
45816     }
45817   }
45818
45819   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45820   return jresult;
45821 }
45822
45823
45824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45825   void * jresult ;
45826   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45827   std::size_t arg2 ;
45828   Dali::ImageDimensions arg3 ;
45829   Dali::FittingMode::Type arg4 ;
45830   Dali::SamplingMode::Type arg5 ;
45831   Dali::ImageDimensions *argp3 ;
45832   Dali::EncodedBufferImage result;
45833
45834   arg1 = (uint8_t *)jarg1;
45835   arg2 = (std::size_t)jarg2;
45836   argp3 = (Dali::ImageDimensions *)jarg3;
45837   if (!argp3) {
45838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45839     return 0;
45840   }
45841   arg3 = *argp3;
45842   arg4 = (Dali::FittingMode::Type)jarg4;
45843   arg5 = (Dali::SamplingMode::Type)jarg5;
45844   {
45845     try {
45846       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45847     } catch (std::out_of_range& e) {
45848       {
45849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45850       };
45851     } catch (std::exception& e) {
45852       {
45853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45854       };
45855     } catch (Dali::DaliException e) {
45856       {
45857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45858       };
45859     } catch (...) {
45860       {
45861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45862       };
45863     }
45864   }
45865
45866   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45867   return jresult;
45868 }
45869
45870
45871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45872   void * jresult ;
45873   Dali::BaseHandle arg1 ;
45874   Dali::BaseHandle *argp1 ;
45875   Dali::EncodedBufferImage result;
45876
45877   argp1 = (Dali::BaseHandle *)jarg1;
45878   if (!argp1) {
45879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45880     return 0;
45881   }
45882   arg1 = *argp1;
45883   {
45884     try {
45885       result = Dali::EncodedBufferImage::DownCast(arg1);
45886     } catch (std::out_of_range& e) {
45887       {
45888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45889       };
45890     } catch (std::exception& e) {
45891       {
45892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45893       };
45894     } catch (Dali::DaliException e) {
45895       {
45896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45897       };
45898     } catch (...) {
45899       {
45900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45901       };
45902     }
45903   }
45904
45905   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45906   return jresult;
45907 }
45908
45909
45910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45911   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45912
45913   arg1 = (Dali::EncodedBufferImage *)jarg1;
45914   {
45915     try {
45916       delete arg1;
45917     } catch (std::out_of_range& e) {
45918       {
45919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45920       };
45921     } catch (std::exception& e) {
45922       {
45923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45924       };
45925     } catch (Dali::DaliException e) {
45926       {
45927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45928       };
45929     } catch (...) {
45930       {
45931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45932       };
45933     }
45934   }
45935
45936 }
45937
45938
45939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45940   void * jresult ;
45941   Dali::EncodedBufferImage *arg1 = 0 ;
45942   Dali::EncodedBufferImage *result = 0 ;
45943
45944   arg1 = (Dali::EncodedBufferImage *)jarg1;
45945   if (!arg1) {
45946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45947     return 0;
45948   }
45949   {
45950     try {
45951       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45952     } catch (std::out_of_range& e) {
45953       {
45954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45955       };
45956     } catch (std::exception& e) {
45957       {
45958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45959       };
45960     } catch (Dali::DaliException e) {
45961       {
45962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45963       };
45964     } catch (...) {
45965       {
45966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45967       };
45968     }
45969   }
45970
45971   jresult = (void *)result;
45972   return jresult;
45973 }
45974
45975
45976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45977   void * jresult ;
45978   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45979   Dali::EncodedBufferImage *arg2 = 0 ;
45980   Dali::EncodedBufferImage *result = 0 ;
45981
45982   arg1 = (Dali::EncodedBufferImage *)jarg1;
45983   arg2 = (Dali::EncodedBufferImage *)jarg2;
45984   if (!arg2) {
45985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45986     return 0;
45987   }
45988   {
45989     try {
45990       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45991     } catch (std::out_of_range& e) {
45992       {
45993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45994       };
45995     } catch (std::exception& e) {
45996       {
45997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45998       };
45999     } catch (Dali::DaliException e) {
46000       {
46001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46002       };
46003     } catch (...) {
46004       {
46005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46006       };
46007     }
46008   }
46009
46010   jresult = (void *)result;
46011   return jresult;
46012 }
46013
46014
46015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46016   void * jresult ;
46017   Dali::NativeImage *result = 0 ;
46018
46019   {
46020     try {
46021       result = (Dali::NativeImage *)new Dali::NativeImage();
46022     } catch (std::out_of_range& e) {
46023       {
46024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46025       };
46026     } catch (std::exception& e) {
46027       {
46028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46029       };
46030     } catch (Dali::DaliException e) {
46031       {
46032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46033       };
46034     } catch (...) {
46035       {
46036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46037       };
46038     }
46039   }
46040
46041   jresult = (void *)result;
46042   return jresult;
46043 }
46044
46045
46046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46047   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46048
46049   arg1 = (Dali::NativeImage *)jarg1;
46050   {
46051     try {
46052       delete arg1;
46053     } catch (std::out_of_range& e) {
46054       {
46055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46056       };
46057     } catch (std::exception& e) {
46058       {
46059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46060       };
46061     } catch (Dali::DaliException e) {
46062       {
46063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46064       };
46065     } catch (...) {
46066       {
46067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46068       };
46069     }
46070   }
46071
46072 }
46073
46074
46075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46076   void * jresult ;
46077   Dali::NativeImage *arg1 = 0 ;
46078   Dali::NativeImage *result = 0 ;
46079
46080   arg1 = (Dali::NativeImage *)jarg1;
46081   if (!arg1) {
46082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46083     return 0;
46084   }
46085   {
46086     try {
46087       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46088     } catch (std::out_of_range& e) {
46089       {
46090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46091       };
46092     } catch (std::exception& e) {
46093       {
46094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46095       };
46096     } catch (Dali::DaliException e) {
46097       {
46098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46099       };
46100     } catch (...) {
46101       {
46102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46103       };
46104     }
46105   }
46106
46107   jresult = (void *)result;
46108   return jresult;
46109 }
46110
46111
46112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46113   void * jresult ;
46114   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46115   Dali::NativeImage *arg2 = 0 ;
46116   Dali::NativeImage *result = 0 ;
46117
46118   arg1 = (Dali::NativeImage *)jarg1;
46119   arg2 = (Dali::NativeImage *)jarg2;
46120   if (!arg2) {
46121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46122     return 0;
46123   }
46124   {
46125     try {
46126       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46127     } catch (std::out_of_range& e) {
46128       {
46129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46130       };
46131     } catch (std::exception& e) {
46132       {
46133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46134       };
46135     } catch (Dali::DaliException e) {
46136       {
46137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46138       };
46139     } catch (...) {
46140       {
46141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46142       };
46143     }
46144   }
46145
46146   jresult = (void *)result;
46147   return jresult;
46148 }
46149
46150
46151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46152   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46153
46154   arg1 = (Dali::NativeImage *)jarg1;
46155   {
46156     try {
46157       (arg1)->CreateGlTexture();
46158     } catch (std::out_of_range& e) {
46159       {
46160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46161       };
46162     } catch (std::exception& e) {
46163       {
46164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46165       };
46166     } catch (Dali::DaliException e) {
46167       {
46168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46169       };
46170     } catch (...) {
46171       {
46172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46173       };
46174     }
46175   }
46176
46177 }
46178
46179
46180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46181   void * jresult ;
46182   NativeImageInterface *arg1 = 0 ;
46183   Dali::NativeImage result;
46184
46185   arg1 = (NativeImageInterface *)jarg1;
46186   if (!arg1) {
46187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46188     return 0;
46189   }
46190   {
46191     try {
46192       result = Dali::NativeImage::New(*arg1);
46193     } catch (std::out_of_range& e) {
46194       {
46195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46196       };
46197     } catch (std::exception& e) {
46198       {
46199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46200       };
46201     } catch (Dali::DaliException e) {
46202       {
46203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46204       };
46205     } catch (...) {
46206       {
46207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46208       };
46209     }
46210   }
46211
46212   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46213   return jresult;
46214 }
46215
46216
46217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46218   void * jresult ;
46219   Dali::BaseHandle arg1 ;
46220   Dali::BaseHandle *argp1 ;
46221   Dali::NativeImage result;
46222
46223   argp1 = (Dali::BaseHandle *)jarg1;
46224   if (!argp1) {
46225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46226     return 0;
46227   }
46228   arg1 = *argp1;
46229   {
46230     try {
46231       result = Dali::NativeImage::DownCast(arg1);
46232     } catch (std::out_of_range& e) {
46233       {
46234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46235       };
46236     } catch (std::exception& e) {
46237       {
46238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46239       };
46240     } catch (Dali::DaliException e) {
46241       {
46242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46243       };
46244     } catch (...) {
46245       {
46246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46247       };
46248     }
46249   }
46250
46251   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46252   return jresult;
46253 }
46254
46255
46256 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46257   char * jresult ;
46258   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46259   char *result = 0 ;
46260
46261   arg1 = (Dali::NativeImage *)jarg1;
46262   {
46263     try {
46264       result = (char *)(arg1)->GetCustomFragmentPreFix();
46265     } catch (std::out_of_range& e) {
46266       {
46267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46268       };
46269     } catch (std::exception& e) {
46270       {
46271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46272       };
46273     } catch (Dali::DaliException e) {
46274       {
46275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46276       };
46277     } catch (...) {
46278       {
46279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46280       };
46281     }
46282   }
46283
46284   jresult = SWIG_csharp_string_callback((const char *)result);
46285   return jresult;
46286 }
46287
46288
46289 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46290   char * jresult ;
46291   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46292   char *result = 0 ;
46293
46294   arg1 = (Dali::NativeImage *)jarg1;
46295   {
46296     try {
46297       result = (char *)(arg1)->GetCustomSamplerTypename();
46298     } catch (std::out_of_range& e) {
46299       {
46300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46301       };
46302     } catch (std::exception& e) {
46303       {
46304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46305       };
46306     } catch (Dali::DaliException e) {
46307       {
46308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46309       };
46310     } catch (...) {
46311       {
46312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46313       };
46314     }
46315   }
46316
46317   jresult = SWIG_csharp_string_callback((const char *)result);
46318   return jresult;
46319 }
46320
46321
46322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46323   unsigned int jresult ;
46324   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46325   bool result;
46326
46327   arg1 = (Dali::NativeImageInterface *)jarg1;
46328   {
46329     try {
46330       result = (bool)(arg1)->GlExtensionCreate();
46331     } catch (std::out_of_range& e) {
46332       {
46333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46334       };
46335     } catch (std::exception& e) {
46336       {
46337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46338       };
46339     } catch (Dali::DaliException e) {
46340       {
46341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46342       };
46343     } catch (...) {
46344       {
46345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46346       };
46347     }
46348   }
46349
46350   jresult = result;
46351   return jresult;
46352 }
46353
46354
46355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46356   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46357
46358   arg1 = (Dali::NativeImageInterface *)jarg1;
46359   {
46360     try {
46361       (arg1)->GlExtensionDestroy();
46362     } catch (std::out_of_range& e) {
46363       {
46364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46365       };
46366     } catch (std::exception& e) {
46367       {
46368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46369       };
46370     } catch (Dali::DaliException e) {
46371       {
46372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46373       };
46374     } catch (...) {
46375       {
46376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46377       };
46378     }
46379   }
46380
46381 }
46382
46383
46384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46385   unsigned int jresult ;
46386   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46387   unsigned int result;
46388
46389   arg1 = (Dali::NativeImageInterface *)jarg1;
46390   {
46391     try {
46392       result = (unsigned int)(arg1)->TargetTexture();
46393     } catch (std::out_of_range& e) {
46394       {
46395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46396       };
46397     } catch (std::exception& e) {
46398       {
46399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46400       };
46401     } catch (Dali::DaliException e) {
46402       {
46403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46404       };
46405     } catch (...) {
46406       {
46407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46408       };
46409     }
46410   }
46411
46412   jresult = result;
46413   return jresult;
46414 }
46415
46416
46417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46418   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46419
46420   arg1 = (Dali::NativeImageInterface *)jarg1;
46421   {
46422     try {
46423       (arg1)->PrepareTexture();
46424     } catch (std::out_of_range& e) {
46425       {
46426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46427       };
46428     } catch (std::exception& e) {
46429       {
46430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46431       };
46432     } catch (Dali::DaliException e) {
46433       {
46434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46435       };
46436     } catch (...) {
46437       {
46438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46439       };
46440     }
46441   }
46442
46443 }
46444
46445
46446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46447   unsigned int jresult ;
46448   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46449   unsigned int result;
46450
46451   arg1 = (Dali::NativeImageInterface *)jarg1;
46452   {
46453     try {
46454       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46455     } catch (std::out_of_range& e) {
46456       {
46457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46458       };
46459     } catch (std::exception& e) {
46460       {
46461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46462       };
46463     } catch (Dali::DaliException e) {
46464       {
46465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46466       };
46467     } catch (...) {
46468       {
46469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46470       };
46471     }
46472   }
46473
46474   jresult = result;
46475   return jresult;
46476 }
46477
46478
46479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46480   unsigned int jresult ;
46481   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46482   unsigned int result;
46483
46484   arg1 = (Dali::NativeImageInterface *)jarg1;
46485   {
46486     try {
46487       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46488     } catch (std::out_of_range& e) {
46489       {
46490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46491       };
46492     } catch (std::exception& e) {
46493       {
46494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46495       };
46496     } catch (Dali::DaliException e) {
46497       {
46498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46499       };
46500     } catch (...) {
46501       {
46502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46503       };
46504     }
46505   }
46506
46507   jresult = result;
46508   return jresult;
46509 }
46510
46511
46512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46513   unsigned int jresult ;
46514   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46515   bool result;
46516
46517   arg1 = (Dali::NativeImageInterface *)jarg1;
46518   {
46519     try {
46520       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46521     } catch (std::out_of_range& e) {
46522       {
46523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46524       };
46525     } catch (std::exception& e) {
46526       {
46527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46528       };
46529     } catch (Dali::DaliException e) {
46530       {
46531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46532       };
46533     } catch (...) {
46534       {
46535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46536       };
46537     }
46538   }
46539
46540   jresult = result;
46541   return jresult;
46542 }
46543
46544
46545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46546   void * jresult ;
46547   std::string *arg1 = 0 ;
46548   Dali::ImageDimensions result;
46549
46550   if (!jarg1) {
46551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46552     return 0;
46553   }
46554   std::string arg1_str(jarg1);
46555   arg1 = &arg1_str;
46556   {
46557     try {
46558       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46559     } catch (std::out_of_range& e) {
46560       {
46561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46562       };
46563     } catch (std::exception& e) {
46564       {
46565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46566       };
46567     } catch (Dali::DaliException e) {
46568       {
46569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46570       };
46571     } catch (...) {
46572       {
46573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46574       };
46575     }
46576   }
46577
46578   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46579
46580   //argout typemap for const std::string&
46581
46582   return jresult;
46583 }
46584
46585
46586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46587   void * jresult ;
46588   Dali::ResourceImage *result = 0 ;
46589
46590   {
46591     try {
46592       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46593     } catch (std::out_of_range& e) {
46594       {
46595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46596       };
46597     } catch (std::exception& e) {
46598       {
46599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46600       };
46601     } catch (Dali::DaliException e) {
46602       {
46603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46604       };
46605     } catch (...) {
46606       {
46607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46608       };
46609     }
46610   }
46611
46612   jresult = (void *)result;
46613   return jresult;
46614 }
46615
46616
46617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46618   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46619
46620   arg1 = (Dali::ResourceImage *)jarg1;
46621   {
46622     try {
46623       delete arg1;
46624     } catch (std::out_of_range& e) {
46625       {
46626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46627       };
46628     } catch (std::exception& e) {
46629       {
46630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46631       };
46632     } catch (Dali::DaliException e) {
46633       {
46634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46635       };
46636     } catch (...) {
46637       {
46638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46639       };
46640     }
46641   }
46642
46643 }
46644
46645
46646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46647   void * jresult ;
46648   Dali::ResourceImage *arg1 = 0 ;
46649   Dali::ResourceImage *result = 0 ;
46650
46651   arg1 = (Dali::ResourceImage *)jarg1;
46652   if (!arg1) {
46653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46654     return 0;
46655   }
46656   {
46657     try {
46658       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46659     } catch (std::out_of_range& e) {
46660       {
46661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46662       };
46663     } catch (std::exception& e) {
46664       {
46665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46666       };
46667     } catch (Dali::DaliException e) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46670       };
46671     } catch (...) {
46672       {
46673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46674       };
46675     }
46676   }
46677
46678   jresult = (void *)result;
46679   return jresult;
46680 }
46681
46682
46683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46684   void * jresult ;
46685   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46686   Dali::ResourceImage *arg2 = 0 ;
46687   Dali::ResourceImage *result = 0 ;
46688
46689   arg1 = (Dali::ResourceImage *)jarg1;
46690   arg2 = (Dali::ResourceImage *)jarg2;
46691   if (!arg2) {
46692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46693     return 0;
46694   }
46695   {
46696     try {
46697       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46698     } catch (std::out_of_range& e) {
46699       {
46700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46701       };
46702     } catch (std::exception& e) {
46703       {
46704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46705       };
46706     } catch (Dali::DaliException e) {
46707       {
46708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46709       };
46710     } catch (...) {
46711       {
46712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46713       };
46714     }
46715   }
46716
46717   jresult = (void *)result;
46718   return jresult;
46719 }
46720
46721
46722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46723   void * jresult ;
46724   std::string *arg1 = 0 ;
46725   bool arg2 ;
46726   Dali::ResourceImage result;
46727
46728   if (!jarg1) {
46729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46730     return 0;
46731   }
46732   std::string arg1_str(jarg1);
46733   arg1 = &arg1_str;
46734   arg2 = jarg2 ? true : false;
46735   {
46736     try {
46737       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46738     } catch (std::out_of_range& e) {
46739       {
46740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46741       };
46742     } catch (std::exception& e) {
46743       {
46744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46745       };
46746     } catch (Dali::DaliException e) {
46747       {
46748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46749       };
46750     } catch (...) {
46751       {
46752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46753       };
46754     }
46755   }
46756
46757   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46758
46759   //argout typemap for const std::string&
46760
46761   return jresult;
46762 }
46763
46764
46765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46766   void * jresult ;
46767   std::string *arg1 = 0 ;
46768   Dali::ResourceImage result;
46769
46770   if (!jarg1) {
46771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46772     return 0;
46773   }
46774   std::string arg1_str(jarg1);
46775   arg1 = &arg1_str;
46776   {
46777     try {
46778       result = Dali::ResourceImage::New((std::string const &)*arg1);
46779     } catch (std::out_of_range& e) {
46780       {
46781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46782       };
46783     } catch (std::exception& e) {
46784       {
46785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46786       };
46787     } catch (Dali::DaliException e) {
46788       {
46789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46790       };
46791     } catch (...) {
46792       {
46793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46794       };
46795     }
46796   }
46797
46798   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46799
46800   //argout typemap for const std::string&
46801
46802   return jresult;
46803 }
46804
46805
46806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46807   void * jresult ;
46808   std::string *arg1 = 0 ;
46809   Dali::ImageDimensions arg2 ;
46810   Dali::FittingMode::Type arg3 ;
46811   Dali::SamplingMode::Type arg4 ;
46812   bool arg5 ;
46813   Dali::ImageDimensions *argp2 ;
46814   Dali::ResourceImage result;
46815
46816   if (!jarg1) {
46817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46818     return 0;
46819   }
46820   std::string arg1_str(jarg1);
46821   arg1 = &arg1_str;
46822   argp2 = (Dali::ImageDimensions *)jarg2;
46823   if (!argp2) {
46824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46825     return 0;
46826   }
46827   arg2 = *argp2;
46828   arg3 = (Dali::FittingMode::Type)jarg3;
46829   arg4 = (Dali::SamplingMode::Type)jarg4;
46830   arg5 = jarg5 ? true : false;
46831   {
46832     try {
46833       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46834     } catch (std::out_of_range& e) {
46835       {
46836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46837       };
46838     } catch (std::exception& e) {
46839       {
46840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46841       };
46842     } catch (Dali::DaliException e) {
46843       {
46844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46845       };
46846     } catch (...) {
46847       {
46848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46849       };
46850     }
46851   }
46852
46853   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46854
46855   //argout typemap for const std::string&
46856
46857   return jresult;
46858 }
46859
46860
46861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46862   void * jresult ;
46863   std::string *arg1 = 0 ;
46864   Dali::ImageDimensions arg2 ;
46865   Dali::FittingMode::Type arg3 ;
46866   Dali::SamplingMode::Type arg4 ;
46867   Dali::ImageDimensions *argp2 ;
46868   Dali::ResourceImage result;
46869
46870   if (!jarg1) {
46871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46872     return 0;
46873   }
46874   std::string arg1_str(jarg1);
46875   arg1 = &arg1_str;
46876   argp2 = (Dali::ImageDimensions *)jarg2;
46877   if (!argp2) {
46878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46879     return 0;
46880   }
46881   arg2 = *argp2;
46882   arg3 = (Dali::FittingMode::Type)jarg3;
46883   arg4 = (Dali::SamplingMode::Type)jarg4;
46884   {
46885     try {
46886       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46887     } catch (std::out_of_range& e) {
46888       {
46889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46890       };
46891     } catch (std::exception& e) {
46892       {
46893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46894       };
46895     } catch (Dali::DaliException e) {
46896       {
46897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46898       };
46899     } catch (...) {
46900       {
46901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46902       };
46903     }
46904   }
46905
46906   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46907
46908   //argout typemap for const std::string&
46909
46910   return jresult;
46911 }
46912
46913
46914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46915   void * jresult ;
46916   std::string *arg1 = 0 ;
46917   Dali::ImageDimensions arg2 ;
46918   Dali::FittingMode::Type arg3 ;
46919   Dali::ImageDimensions *argp2 ;
46920   Dali::ResourceImage result;
46921
46922   if (!jarg1) {
46923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46924     return 0;
46925   }
46926   std::string arg1_str(jarg1);
46927   arg1 = &arg1_str;
46928   argp2 = (Dali::ImageDimensions *)jarg2;
46929   if (!argp2) {
46930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46931     return 0;
46932   }
46933   arg2 = *argp2;
46934   arg3 = (Dali::FittingMode::Type)jarg3;
46935   {
46936     try {
46937       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46938     } catch (std::out_of_range& e) {
46939       {
46940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46941       };
46942     } catch (std::exception& e) {
46943       {
46944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46945       };
46946     } catch (Dali::DaliException e) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46949       };
46950     } catch (...) {
46951       {
46952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46953       };
46954     }
46955   }
46956
46957   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46958
46959   //argout typemap for const std::string&
46960
46961   return jresult;
46962 }
46963
46964
46965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46966   void * jresult ;
46967   std::string *arg1 = 0 ;
46968   Dali::ImageDimensions arg2 ;
46969   Dali::ImageDimensions *argp2 ;
46970   Dali::ResourceImage result;
46971
46972   if (!jarg1) {
46973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46974     return 0;
46975   }
46976   std::string arg1_str(jarg1);
46977   arg1 = &arg1_str;
46978   argp2 = (Dali::ImageDimensions *)jarg2;
46979   if (!argp2) {
46980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46981     return 0;
46982   }
46983   arg2 = *argp2;
46984   {
46985     try {
46986       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46987     } catch (std::out_of_range& e) {
46988       {
46989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46990       };
46991     } catch (std::exception& e) {
46992       {
46993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46994       };
46995     } catch (Dali::DaliException e) {
46996       {
46997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46998       };
46999     } catch (...) {
47000       {
47001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47002       };
47003     }
47004   }
47005
47006   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47007
47008   //argout typemap for const std::string&
47009
47010   return jresult;
47011 }
47012
47013
47014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47015   void * jresult ;
47016   Dali::BaseHandle arg1 ;
47017   Dali::BaseHandle *argp1 ;
47018   Dali::ResourceImage result;
47019
47020   argp1 = (Dali::BaseHandle *)jarg1;
47021   if (!argp1) {
47022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47023     return 0;
47024   }
47025   arg1 = *argp1;
47026   {
47027     try {
47028       result = Dali::ResourceImage::DownCast(arg1);
47029     } catch (std::out_of_range& e) {
47030       {
47031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47032       };
47033     } catch (std::exception& e) {
47034       {
47035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47036       };
47037     } catch (Dali::DaliException e) {
47038       {
47039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47040       };
47041     } catch (...) {
47042       {
47043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47044       };
47045     }
47046   }
47047
47048   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47049   return jresult;
47050 }
47051
47052
47053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47054   int jresult ;
47055   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47056   Dali::LoadingState result;
47057
47058   arg1 = (Dali::ResourceImage *)jarg1;
47059   {
47060     try {
47061       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47062     } catch (std::out_of_range& e) {
47063       {
47064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47065       };
47066     } catch (std::exception& e) {
47067       {
47068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47069       };
47070     } catch (Dali::DaliException e) {
47071       {
47072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47073       };
47074     } catch (...) {
47075       {
47076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47077       };
47078     }
47079   }
47080
47081   jresult = (int)result;
47082   return jresult;
47083 }
47084
47085
47086 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47087   char * jresult ;
47088   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47089   std::string result;
47090
47091   arg1 = (Dali::ResourceImage *)jarg1;
47092   {
47093     try {
47094       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47095     } catch (std::out_of_range& e) {
47096       {
47097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47098       };
47099     } catch (std::exception& e) {
47100       {
47101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47102       };
47103     } catch (Dali::DaliException e) {
47104       {
47105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47106       };
47107     } catch (...) {
47108       {
47109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47110       };
47111     }
47112   }
47113
47114   jresult = SWIG_csharp_string_callback((&result)->c_str());
47115   return jresult;
47116 }
47117
47118
47119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47120   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47121
47122   arg1 = (Dali::ResourceImage *)jarg1;
47123   {
47124     try {
47125       (arg1)->Reload();
47126     } catch (std::out_of_range& e) {
47127       {
47128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47129       };
47130     } catch (std::exception& e) {
47131       {
47132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47133       };
47134     } catch (Dali::DaliException e) {
47135       {
47136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47137       };
47138     } catch (...) {
47139       {
47140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47141       };
47142     }
47143   }
47144
47145 }
47146
47147
47148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47149   void * jresult ;
47150   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47151   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47152
47153   arg1 = (Dali::ResourceImage *)jarg1;
47154   {
47155     try {
47156       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47157     } catch (std::out_of_range& e) {
47158       {
47159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47160       };
47161     } catch (std::exception& e) {
47162       {
47163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47164       };
47165     } catch (Dali::DaliException e) {
47166       {
47167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47168       };
47169     } catch (...) {
47170       {
47171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47172       };
47173     }
47174   }
47175
47176   jresult = (void *)result;
47177   return jresult;
47178 }
47179
47180
47181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47182   void * jresult ;
47183   Dali::FrameBufferImage *result = 0 ;
47184
47185   {
47186     try {
47187       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47188     } catch (std::out_of_range& e) {
47189       {
47190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47191       };
47192     } catch (std::exception& e) {
47193       {
47194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47195       };
47196     } catch (Dali::DaliException e) {
47197       {
47198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47199       };
47200     } catch (...) {
47201       {
47202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47203       };
47204     }
47205   }
47206
47207   jresult = (void *)result;
47208   return jresult;
47209 }
47210
47211
47212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47213   void * jresult ;
47214   unsigned int arg1 ;
47215   unsigned int arg2 ;
47216   Dali::Pixel::Format arg3 ;
47217   Dali::RenderBuffer::Format arg4 ;
47218   Dali::FrameBufferImage result;
47219
47220   arg1 = (unsigned int)jarg1;
47221   arg2 = (unsigned int)jarg2;
47222   arg3 = (Dali::Pixel::Format)jarg3;
47223   arg4 = (Dali::RenderBuffer::Format)jarg4;
47224   {
47225     try {
47226       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47227     } catch (std::out_of_range& e) {
47228       {
47229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47230       };
47231     } catch (std::exception& e) {
47232       {
47233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47234       };
47235     } catch (Dali::DaliException e) {
47236       {
47237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47238       };
47239     } catch (...) {
47240       {
47241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47242       };
47243     }
47244   }
47245
47246   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47247   return jresult;
47248 }
47249
47250
47251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47252   void * jresult ;
47253   unsigned int arg1 ;
47254   unsigned int arg2 ;
47255   Dali::Pixel::Format arg3 ;
47256   Dali::FrameBufferImage result;
47257
47258   arg1 = (unsigned int)jarg1;
47259   arg2 = (unsigned int)jarg2;
47260   arg3 = (Dali::Pixel::Format)jarg3;
47261   {
47262     try {
47263       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47264     } catch (std::out_of_range& e) {
47265       {
47266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47267       };
47268     } catch (std::exception& e) {
47269       {
47270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47271       };
47272     } catch (Dali::DaliException e) {
47273       {
47274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47275       };
47276     } catch (...) {
47277       {
47278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47279       };
47280     }
47281   }
47282
47283   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47284   return jresult;
47285 }
47286
47287
47288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47289   void * jresult ;
47290   unsigned int arg1 ;
47291   unsigned int arg2 ;
47292   Dali::FrameBufferImage result;
47293
47294   arg1 = (unsigned int)jarg1;
47295   arg2 = (unsigned int)jarg2;
47296   {
47297     try {
47298       result = Dali::FrameBufferImage::New(arg1,arg2);
47299     } catch (std::out_of_range& e) {
47300       {
47301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47302       };
47303     } catch (std::exception& e) {
47304       {
47305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47306       };
47307     } catch (Dali::DaliException e) {
47308       {
47309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47310       };
47311     } catch (...) {
47312       {
47313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47314       };
47315     }
47316   }
47317
47318   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47319   return jresult;
47320 }
47321
47322
47323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47324   void * jresult ;
47325   unsigned int arg1 ;
47326   Dali::FrameBufferImage result;
47327
47328   arg1 = (unsigned int)jarg1;
47329   {
47330     try {
47331       result = Dali::FrameBufferImage::New(arg1);
47332     } catch (std::out_of_range& e) {
47333       {
47334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47335       };
47336     } catch (std::exception& e) {
47337       {
47338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47339       };
47340     } catch (Dali::DaliException e) {
47341       {
47342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47343       };
47344     } catch (...) {
47345       {
47346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47347       };
47348     }
47349   }
47350
47351   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47352   return jresult;
47353 }
47354
47355
47356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47357   void * jresult ;
47358   Dali::FrameBufferImage result;
47359
47360   {
47361     try {
47362       result = Dali::FrameBufferImage::New();
47363     } catch (std::out_of_range& e) {
47364       {
47365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47366       };
47367     } catch (std::exception& e) {
47368       {
47369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47370       };
47371     } catch (Dali::DaliException e) {
47372       {
47373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47374       };
47375     } catch (...) {
47376       {
47377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47378       };
47379     }
47380   }
47381
47382   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47383   return jresult;
47384 }
47385
47386
47387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47388   void * jresult ;
47389   Dali::NativeImageInterface *arg1 = 0 ;
47390   Dali::FrameBufferImage result;
47391
47392   arg1 = (Dali::NativeImageInterface *)jarg1;
47393   if (!arg1) {
47394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47395     return 0;
47396   }
47397   {
47398     try {
47399       result = Dali::FrameBufferImage::New(*arg1);
47400     } catch (std::out_of_range& e) {
47401       {
47402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47403       };
47404     } catch (std::exception& e) {
47405       {
47406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47407       };
47408     } catch (Dali::DaliException e) {
47409       {
47410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47411       };
47412     } catch (...) {
47413       {
47414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47415       };
47416     }
47417   }
47418
47419   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47420   return jresult;
47421 }
47422
47423
47424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47425   void * jresult ;
47426   Dali::BaseHandle arg1 ;
47427   Dali::BaseHandle *argp1 ;
47428   Dali::FrameBufferImage result;
47429
47430   argp1 = (Dali::BaseHandle *)jarg1;
47431   if (!argp1) {
47432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47433     return 0;
47434   }
47435   arg1 = *argp1;
47436   {
47437     try {
47438       result = Dali::FrameBufferImage::DownCast(arg1);
47439     } catch (std::out_of_range& e) {
47440       {
47441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47442       };
47443     } catch (std::exception& e) {
47444       {
47445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47446       };
47447     } catch (Dali::DaliException e) {
47448       {
47449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47450       };
47451     } catch (...) {
47452       {
47453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47454       };
47455     }
47456   }
47457
47458   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47459   return jresult;
47460 }
47461
47462
47463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47464   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47465
47466   arg1 = (Dali::FrameBufferImage *)jarg1;
47467   {
47468     try {
47469       delete arg1;
47470     } catch (std::out_of_range& e) {
47471       {
47472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47473       };
47474     } catch (std::exception& e) {
47475       {
47476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47477       };
47478     } catch (Dali::DaliException e) {
47479       {
47480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47481       };
47482     } catch (...) {
47483       {
47484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47485       };
47486     }
47487   }
47488
47489 }
47490
47491
47492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47493   void * jresult ;
47494   Dali::FrameBufferImage *arg1 = 0 ;
47495   Dali::FrameBufferImage *result = 0 ;
47496
47497   arg1 = (Dali::FrameBufferImage *)jarg1;
47498   if (!arg1) {
47499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47500     return 0;
47501   }
47502   {
47503     try {
47504       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47505     } catch (std::out_of_range& e) {
47506       {
47507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47508       };
47509     } catch (std::exception& e) {
47510       {
47511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47512       };
47513     } catch (Dali::DaliException e) {
47514       {
47515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47516       };
47517     } catch (...) {
47518       {
47519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47520       };
47521     }
47522   }
47523
47524   jresult = (void *)result;
47525   return jresult;
47526 }
47527
47528
47529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47530   void * jresult ;
47531   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47532   Dali::FrameBufferImage *arg2 = 0 ;
47533   Dali::FrameBufferImage *result = 0 ;
47534
47535   arg1 = (Dali::FrameBufferImage *)jarg1;
47536   arg2 = (Dali::FrameBufferImage *)jarg2;
47537   if (!arg2) {
47538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47539     return 0;
47540   }
47541   {
47542     try {
47543       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47544     } catch (std::out_of_range& e) {
47545       {
47546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47547       };
47548     } catch (std::exception& e) {
47549       {
47550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47551       };
47552     } catch (Dali::DaliException e) {
47553       {
47554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47555       };
47556     } catch (...) {
47557       {
47558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47559       };
47560     }
47561   }
47562
47563   jresult = (void *)result;
47564   return jresult;
47565 }
47566
47567
47568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47569   void * jresult ;
47570   Dali::NinePatchImage *result = 0 ;
47571
47572   {
47573     try {
47574       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47575     } catch (std::out_of_range& e) {
47576       {
47577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47578       };
47579     } catch (std::exception& e) {
47580       {
47581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47582       };
47583     } catch (Dali::DaliException e) {
47584       {
47585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47586       };
47587     } catch (...) {
47588       {
47589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47590       };
47591     }
47592   }
47593
47594   jresult = (void *)result;
47595   return jresult;
47596 }
47597
47598
47599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47600   void * jresult ;
47601   std::string *arg1 = 0 ;
47602   Dali::NinePatchImage result;
47603
47604   if (!jarg1) {
47605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47606     return 0;
47607   }
47608   std::string arg1_str(jarg1);
47609   arg1 = &arg1_str;
47610   {
47611     try {
47612       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47613     } catch (std::out_of_range& e) {
47614       {
47615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47616       };
47617     } catch (std::exception& e) {
47618       {
47619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47620       };
47621     } catch (Dali::DaliException e) {
47622       {
47623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47624       };
47625     } catch (...) {
47626       {
47627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47628       };
47629     }
47630   }
47631
47632   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47633
47634   //argout typemap for const std::string&
47635
47636   return jresult;
47637 }
47638
47639
47640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47641   void * jresult ;
47642   Dali::BaseHandle arg1 ;
47643   Dali::BaseHandle *argp1 ;
47644   Dali::NinePatchImage result;
47645
47646   argp1 = (Dali::BaseHandle *)jarg1;
47647   if (!argp1) {
47648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47649     return 0;
47650   }
47651   arg1 = *argp1;
47652   {
47653     try {
47654       result = Dali::NinePatchImage::DownCast(arg1);
47655     } catch (std::out_of_range& e) {
47656       {
47657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47658       };
47659     } catch (std::exception& e) {
47660       {
47661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47662       };
47663     } catch (Dali::DaliException e) {
47664       {
47665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47666       };
47667     } catch (...) {
47668       {
47669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47670       };
47671     }
47672   }
47673
47674   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47675   return jresult;
47676 }
47677
47678
47679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47680   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47681
47682   arg1 = (Dali::NinePatchImage *)jarg1;
47683   {
47684     try {
47685       delete arg1;
47686     } catch (std::out_of_range& e) {
47687       {
47688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47689       };
47690     } catch (std::exception& e) {
47691       {
47692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47693       };
47694     } catch (Dali::DaliException e) {
47695       {
47696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47697       };
47698     } catch (...) {
47699       {
47700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47701       };
47702     }
47703   }
47704
47705 }
47706
47707
47708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47709   void * jresult ;
47710   Dali::NinePatchImage *arg1 = 0 ;
47711   Dali::NinePatchImage *result = 0 ;
47712
47713   arg1 = (Dali::NinePatchImage *)jarg1;
47714   if (!arg1) {
47715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47716     return 0;
47717   }
47718   {
47719     try {
47720       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47721     } catch (std::out_of_range& e) {
47722       {
47723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47724       };
47725     } catch (std::exception& e) {
47726       {
47727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47728       };
47729     } catch (Dali::DaliException e) {
47730       {
47731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47732       };
47733     } catch (...) {
47734       {
47735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47736       };
47737     }
47738   }
47739
47740   jresult = (void *)result;
47741   return jresult;
47742 }
47743
47744
47745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47746   void * jresult ;
47747   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47748   Dali::NinePatchImage *arg2 = 0 ;
47749   Dali::NinePatchImage *result = 0 ;
47750
47751   arg1 = (Dali::NinePatchImage *)jarg1;
47752   arg2 = (Dali::NinePatchImage *)jarg2;
47753   if (!arg2) {
47754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47755     return 0;
47756   }
47757   {
47758     try {
47759       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47760     } catch (std::out_of_range& e) {
47761       {
47762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47763       };
47764     } catch (std::exception& e) {
47765       {
47766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47767       };
47768     } catch (Dali::DaliException e) {
47769       {
47770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47771       };
47772     } catch (...) {
47773       {
47774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47775       };
47776     }
47777   }
47778
47779   jresult = (void *)result;
47780   return jresult;
47781 }
47782
47783
47784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47785   void * jresult ;
47786   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47787   Dali::Vector4 result;
47788
47789   arg1 = (Dali::NinePatchImage *)jarg1;
47790   {
47791     try {
47792       result = (arg1)->GetStretchBorders();
47793     } catch (std::out_of_range& e) {
47794       {
47795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47796       };
47797     } catch (std::exception& e) {
47798       {
47799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47800       };
47801     } catch (Dali::DaliException e) {
47802       {
47803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47804       };
47805     } catch (...) {
47806       {
47807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47808       };
47809     }
47810   }
47811
47812   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47813   return jresult;
47814 }
47815
47816
47817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47818   void * jresult ;
47819   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47820   Dali::NinePatchImage::StretchRanges *result = 0 ;
47821
47822   arg1 = (Dali::NinePatchImage *)jarg1;
47823   {
47824     try {
47825       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47826     } catch (std::out_of_range& e) {
47827       {
47828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47829       };
47830     } catch (std::exception& e) {
47831       {
47832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47833       };
47834     } catch (Dali::DaliException e) {
47835       {
47836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47837       };
47838     } catch (...) {
47839       {
47840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47841       };
47842     }
47843   }
47844
47845   jresult = (void *)result;
47846   return jresult;
47847 }
47848
47849
47850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47851   void * jresult ;
47852   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47853   Dali::NinePatchImage::StretchRanges *result = 0 ;
47854
47855   arg1 = (Dali::NinePatchImage *)jarg1;
47856   {
47857     try {
47858       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47859     } catch (std::out_of_range& e) {
47860       {
47861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47862       };
47863     } catch (std::exception& e) {
47864       {
47865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47866       };
47867     } catch (Dali::DaliException e) {
47868       {
47869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47870       };
47871     } catch (...) {
47872       {
47873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47874       };
47875     }
47876   }
47877
47878   jresult = (void *)result;
47879   return jresult;
47880 }
47881
47882
47883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47884   void * jresult ;
47885   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47886   Dali::Rect< int > result;
47887
47888   arg1 = (Dali::NinePatchImage *)jarg1;
47889   {
47890     try {
47891       result = (arg1)->GetChildRectangle();
47892     } catch (std::out_of_range& e) {
47893       {
47894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47895       };
47896     } catch (std::exception& e) {
47897       {
47898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47899       };
47900     } catch (Dali::DaliException e) {
47901       {
47902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47903       };
47904     } catch (...) {
47905       {
47906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47907       };
47908     }
47909   }
47910
47911   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47912   return jresult;
47913 }
47914
47915
47916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47917   void * jresult ;
47918   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47919   Dali::BufferImage result;
47920
47921   arg1 = (Dali::NinePatchImage *)jarg1;
47922   {
47923     try {
47924       result = (arg1)->CreateCroppedBufferImage();
47925     } catch (std::out_of_range& e) {
47926       {
47927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47928       };
47929     } catch (std::exception& e) {
47930       {
47931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47932       };
47933     } catch (Dali::DaliException e) {
47934       {
47935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47936       };
47937     } catch (...) {
47938       {
47939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47940       };
47941     }
47942   }
47943
47944   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47945   return jresult;
47946 }
47947
47948
47949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47950   unsigned int jresult ;
47951   std::string *arg1 = 0 ;
47952   bool result;
47953
47954   if (!jarg1) {
47955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47956     return 0;
47957   }
47958   std::string arg1_str(jarg1);
47959   arg1 = &arg1_str;
47960   {
47961     try {
47962       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47963     } catch (std::out_of_range& e) {
47964       {
47965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47966       };
47967     } catch (std::exception& e) {
47968       {
47969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47970       };
47971     } catch (Dali::DaliException e) {
47972       {
47973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47974       };
47975     } catch (...) {
47976       {
47977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47978       };
47979     }
47980   }
47981
47982   jresult = result;
47983
47984   //argout typemap for const std::string&
47985
47986   return jresult;
47987 }
47988
47989
47990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47991   int jresult ;
47992   int result;
47993
47994   result = (int)Dali::CameraActor::Property::TYPE;
47995   jresult = (int)result;
47996   return jresult;
47997 }
47998
47999
48000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48001   int jresult ;
48002   int result;
48003
48004   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48005   jresult = (int)result;
48006   return jresult;
48007 }
48008
48009
48010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48011   int jresult ;
48012   int result;
48013
48014   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48015   jresult = (int)result;
48016   return jresult;
48017 }
48018
48019
48020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48021   int jresult ;
48022   int result;
48023
48024   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48025   jresult = (int)result;
48026   return jresult;
48027 }
48028
48029
48030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48031   int jresult ;
48032   int result;
48033
48034   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48035   jresult = (int)result;
48036   return jresult;
48037 }
48038
48039
48040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48041   int jresult ;
48042   int result;
48043
48044   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48045   jresult = (int)result;
48046   return jresult;
48047 }
48048
48049
48050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48051   int jresult ;
48052   int result;
48053
48054   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48055   jresult = (int)result;
48056   return jresult;
48057 }
48058
48059
48060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48061   int jresult ;
48062   int result;
48063
48064   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48065   jresult = (int)result;
48066   return jresult;
48067 }
48068
48069
48070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48071   int jresult ;
48072   int result;
48073
48074   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48075   jresult = (int)result;
48076   return jresult;
48077 }
48078
48079
48080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48081   int jresult ;
48082   int result;
48083
48084   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48085   jresult = (int)result;
48086   return jresult;
48087 }
48088
48089
48090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48091   int jresult ;
48092   int result;
48093
48094   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48095   jresult = (int)result;
48096   return jresult;
48097 }
48098
48099
48100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48101   int jresult ;
48102   int result;
48103
48104   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48105   jresult = (int)result;
48106   return jresult;
48107 }
48108
48109
48110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48111   int jresult ;
48112   int result;
48113
48114   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48115   jresult = (int)result;
48116   return jresult;
48117 }
48118
48119
48120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48121   int jresult ;
48122   int result;
48123
48124   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48125   jresult = (int)result;
48126   return jresult;
48127 }
48128
48129
48130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48131   void * jresult ;
48132   Dali::CameraActor::Property *result = 0 ;
48133
48134   {
48135     try {
48136       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48137     } catch (std::out_of_range& e) {
48138       {
48139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48140       };
48141     } catch (std::exception& e) {
48142       {
48143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (Dali::DaliException e) {
48146       {
48147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48148       };
48149     } catch (...) {
48150       {
48151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48152       };
48153     }
48154   }
48155
48156   jresult = (void *)result;
48157   return jresult;
48158 }
48159
48160
48161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48162   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48163
48164   arg1 = (Dali::CameraActor::Property *)jarg1;
48165   {
48166     try {
48167       delete arg1;
48168     } catch (std::out_of_range& e) {
48169       {
48170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48171       };
48172     } catch (std::exception& e) {
48173       {
48174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48175       };
48176     } catch (Dali::DaliException e) {
48177       {
48178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48179       };
48180     } catch (...) {
48181       {
48182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48183       };
48184     }
48185   }
48186
48187 }
48188
48189
48190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48191   void * jresult ;
48192   Dali::CameraActor *result = 0 ;
48193
48194   {
48195     try {
48196       result = (Dali::CameraActor *)new Dali::CameraActor();
48197     } catch (std::out_of_range& e) {
48198       {
48199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48200       };
48201     } catch (std::exception& e) {
48202       {
48203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48204       };
48205     } catch (Dali::DaliException e) {
48206       {
48207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48208       };
48209     } catch (...) {
48210       {
48211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48212       };
48213     }
48214   }
48215
48216   jresult = (void *)result;
48217   return jresult;
48218 }
48219
48220
48221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48222   void * jresult ;
48223   Dali::CameraActor result;
48224
48225   {
48226     try {
48227       result = Dali::CameraActor::New();
48228     } catch (std::out_of_range& e) {
48229       {
48230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48231       };
48232     } catch (std::exception& e) {
48233       {
48234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48235       };
48236     } catch (Dali::DaliException e) {
48237       {
48238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48239       };
48240     } catch (...) {
48241       {
48242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48243       };
48244     }
48245   }
48246
48247   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48248   return jresult;
48249 }
48250
48251
48252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48253   void * jresult ;
48254   Dali::Size *arg1 = 0 ;
48255   Dali::CameraActor result;
48256
48257   arg1 = (Dali::Size *)jarg1;
48258   if (!arg1) {
48259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48260     return 0;
48261   }
48262   {
48263     try {
48264       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48265     } catch (std::out_of_range& e) {
48266       {
48267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48268       };
48269     } catch (std::exception& e) {
48270       {
48271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48272       };
48273     } catch (Dali::DaliException e) {
48274       {
48275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48276       };
48277     } catch (...) {
48278       {
48279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48280       };
48281     }
48282   }
48283
48284   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48285   return jresult;
48286 }
48287
48288
48289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48290   void * jresult ;
48291   Dali::BaseHandle arg1 ;
48292   Dali::BaseHandle *argp1 ;
48293   Dali::CameraActor result;
48294
48295   argp1 = (Dali::BaseHandle *)jarg1;
48296   if (!argp1) {
48297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48298     return 0;
48299   }
48300   arg1 = *argp1;
48301   {
48302     try {
48303       result = Dali::CameraActor::DownCast(arg1);
48304     } catch (std::out_of_range& e) {
48305       {
48306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48307       };
48308     } catch (std::exception& e) {
48309       {
48310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48311       };
48312     } catch (Dali::DaliException e) {
48313       {
48314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48315       };
48316     } catch (...) {
48317       {
48318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48319       };
48320     }
48321   }
48322
48323   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48324   return jresult;
48325 }
48326
48327
48328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48329   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48330
48331   arg1 = (Dali::CameraActor *)jarg1;
48332   {
48333     try {
48334       delete arg1;
48335     } catch (std::out_of_range& e) {
48336       {
48337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48338       };
48339     } catch (std::exception& e) {
48340       {
48341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48342       };
48343     } catch (Dali::DaliException e) {
48344       {
48345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48346       };
48347     } catch (...) {
48348       {
48349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48350       };
48351     }
48352   }
48353
48354 }
48355
48356
48357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48358   void * jresult ;
48359   Dali::CameraActor *arg1 = 0 ;
48360   Dali::CameraActor *result = 0 ;
48361
48362   arg1 = (Dali::CameraActor *)jarg1;
48363   if (!arg1) {
48364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48365     return 0;
48366   }
48367   {
48368     try {
48369       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48370     } catch (std::out_of_range& e) {
48371       {
48372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48373       };
48374     } catch (std::exception& e) {
48375       {
48376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48377       };
48378     } catch (Dali::DaliException e) {
48379       {
48380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48381       };
48382     } catch (...) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48385       };
48386     }
48387   }
48388
48389   jresult = (void *)result;
48390   return jresult;
48391 }
48392
48393
48394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48395   void * jresult ;
48396   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48397   Dali::CameraActor *arg2 = 0 ;
48398   Dali::CameraActor *result = 0 ;
48399
48400   arg1 = (Dali::CameraActor *)jarg1;
48401   arg2 = (Dali::CameraActor *)jarg2;
48402   if (!arg2) {
48403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48404     return 0;
48405   }
48406   {
48407     try {
48408       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48409     } catch (std::out_of_range& e) {
48410       {
48411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48412       };
48413     } catch (std::exception& e) {
48414       {
48415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48416       };
48417     } catch (Dali::DaliException e) {
48418       {
48419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48420       };
48421     } catch (...) {
48422       {
48423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48424       };
48425     }
48426   }
48427
48428   jresult = (void *)result;
48429   return jresult;
48430 }
48431
48432
48433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48434   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48435   Dali::Camera::Type arg2 ;
48436
48437   arg1 = (Dali::CameraActor *)jarg1;
48438   arg2 = (Dali::Camera::Type)jarg2;
48439   {
48440     try {
48441       (arg1)->SetType(arg2);
48442     } catch (std::out_of_range& e) {
48443       {
48444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48445       };
48446     } catch (std::exception& e) {
48447       {
48448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48449       };
48450     } catch (Dali::DaliException e) {
48451       {
48452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48453       };
48454     } catch (...) {
48455       {
48456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48457       };
48458     }
48459   }
48460
48461 }
48462
48463
48464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48465   int jresult ;
48466   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48467   Dali::Camera::Type result;
48468
48469   arg1 = (Dali::CameraActor *)jarg1;
48470   {
48471     try {
48472       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48473     } catch (std::out_of_range& e) {
48474       {
48475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48476       };
48477     } catch (std::exception& e) {
48478       {
48479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48480       };
48481     } catch (Dali::DaliException e) {
48482       {
48483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48484       };
48485     } catch (...) {
48486       {
48487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48488       };
48489     }
48490   }
48491
48492   jresult = (int)result;
48493   return jresult;
48494 }
48495
48496
48497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48498   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48499   Dali::Camera::ProjectionMode arg2 ;
48500
48501   arg1 = (Dali::CameraActor *)jarg1;
48502   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48503   {
48504     try {
48505       (arg1)->SetProjectionMode(arg2);
48506     } catch (std::out_of_range& e) {
48507       {
48508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48509       };
48510     } catch (std::exception& e) {
48511       {
48512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48513       };
48514     } catch (Dali::DaliException e) {
48515       {
48516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48517       };
48518     } catch (...) {
48519       {
48520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48521       };
48522     }
48523   }
48524
48525 }
48526
48527
48528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48529   int jresult ;
48530   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48531   Dali::Camera::ProjectionMode result;
48532
48533   arg1 = (Dali::CameraActor *)jarg1;
48534   {
48535     try {
48536       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48537     } catch (std::out_of_range& e) {
48538       {
48539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48540       };
48541     } catch (std::exception& e) {
48542       {
48543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48544       };
48545     } catch (Dali::DaliException e) {
48546       {
48547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48548       };
48549     } catch (...) {
48550       {
48551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48552       };
48553     }
48554   }
48555
48556   jresult = (int)result;
48557   return jresult;
48558 }
48559
48560
48561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48562   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48563   float arg2 ;
48564
48565   arg1 = (Dali::CameraActor *)jarg1;
48566   arg2 = (float)jarg2;
48567   {
48568     try {
48569       (arg1)->SetFieldOfView(arg2);
48570     } catch (std::out_of_range& e) {
48571       {
48572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48573       };
48574     } catch (std::exception& e) {
48575       {
48576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48577       };
48578     } catch (Dali::DaliException e) {
48579       {
48580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48581       };
48582     } catch (...) {
48583       {
48584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48585       };
48586     }
48587   }
48588
48589 }
48590
48591
48592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48593   float jresult ;
48594   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48595   float result;
48596
48597   arg1 = (Dali::CameraActor *)jarg1;
48598   {
48599     try {
48600       result = (float)(arg1)->GetFieldOfView();
48601     } catch (std::out_of_range& e) {
48602       {
48603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48604       };
48605     } catch (std::exception& e) {
48606       {
48607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48608       };
48609     } catch (Dali::DaliException e) {
48610       {
48611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48612       };
48613     } catch (...) {
48614       {
48615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48616       };
48617     }
48618   }
48619
48620   jresult = result;
48621   return jresult;
48622 }
48623
48624
48625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48626   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48627   float arg2 ;
48628
48629   arg1 = (Dali::CameraActor *)jarg1;
48630   arg2 = (float)jarg2;
48631   {
48632     try {
48633       (arg1)->SetAspectRatio(arg2);
48634     } catch (std::out_of_range& e) {
48635       {
48636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48637       };
48638     } catch (std::exception& e) {
48639       {
48640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48641       };
48642     } catch (Dali::DaliException e) {
48643       {
48644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48645       };
48646     } catch (...) {
48647       {
48648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48649       };
48650     }
48651   }
48652
48653 }
48654
48655
48656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48657   float jresult ;
48658   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48659   float result;
48660
48661   arg1 = (Dali::CameraActor *)jarg1;
48662   {
48663     try {
48664       result = (float)(arg1)->GetAspectRatio();
48665     } catch (std::out_of_range& e) {
48666       {
48667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48668       };
48669     } catch (std::exception& e) {
48670       {
48671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48672       };
48673     } catch (Dali::DaliException e) {
48674       {
48675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48676       };
48677     } catch (...) {
48678       {
48679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48680       };
48681     }
48682   }
48683
48684   jresult = result;
48685   return jresult;
48686 }
48687
48688
48689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48690   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48691   float arg2 ;
48692
48693   arg1 = (Dali::CameraActor *)jarg1;
48694   arg2 = (float)jarg2;
48695   {
48696     try {
48697       (arg1)->SetNearClippingPlane(arg2);
48698     } catch (std::out_of_range& e) {
48699       {
48700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48701       };
48702     } catch (std::exception& e) {
48703       {
48704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48705       };
48706     } catch (Dali::DaliException e) {
48707       {
48708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48709       };
48710     } catch (...) {
48711       {
48712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48713       };
48714     }
48715   }
48716
48717 }
48718
48719
48720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48721   float jresult ;
48722   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48723   float result;
48724
48725   arg1 = (Dali::CameraActor *)jarg1;
48726   {
48727     try {
48728       result = (float)(arg1)->GetNearClippingPlane();
48729     } catch (std::out_of_range& e) {
48730       {
48731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48732       };
48733     } catch (std::exception& e) {
48734       {
48735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48736       };
48737     } catch (Dali::DaliException e) {
48738       {
48739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48740       };
48741     } catch (...) {
48742       {
48743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48744       };
48745     }
48746   }
48747
48748   jresult = result;
48749   return jresult;
48750 }
48751
48752
48753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48754   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48755   float arg2 ;
48756
48757   arg1 = (Dali::CameraActor *)jarg1;
48758   arg2 = (float)jarg2;
48759   {
48760     try {
48761       (arg1)->SetFarClippingPlane(arg2);
48762     } catch (std::out_of_range& e) {
48763       {
48764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48765       };
48766     } catch (std::exception& e) {
48767       {
48768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48769       };
48770     } catch (Dali::DaliException e) {
48771       {
48772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48773       };
48774     } catch (...) {
48775       {
48776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48777       };
48778     }
48779   }
48780
48781 }
48782
48783
48784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48785   float jresult ;
48786   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48787   float result;
48788
48789   arg1 = (Dali::CameraActor *)jarg1;
48790   {
48791     try {
48792       result = (float)(arg1)->GetFarClippingPlane();
48793     } catch (std::out_of_range& e) {
48794       {
48795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48796       };
48797     } catch (std::exception& e) {
48798       {
48799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48800       };
48801     } catch (Dali::DaliException e) {
48802       {
48803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48804       };
48805     } catch (...) {
48806       {
48807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48808       };
48809     }
48810   }
48811
48812   jresult = result;
48813   return jresult;
48814 }
48815
48816
48817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48818   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48819   Dali::Vector3 *arg2 = 0 ;
48820
48821   arg1 = (Dali::CameraActor *)jarg1;
48822   arg2 = (Dali::Vector3 *)jarg2;
48823   if (!arg2) {
48824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48825     return ;
48826   }
48827   {
48828     try {
48829       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48830     } catch (std::out_of_range& e) {
48831       {
48832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48833       };
48834     } catch (std::exception& e) {
48835       {
48836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48837       };
48838     } catch (Dali::DaliException e) {
48839       {
48840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48841       };
48842     } catch (...) {
48843       {
48844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48845       };
48846     }
48847   }
48848
48849 }
48850
48851
48852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48853   void * jresult ;
48854   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48855   Dali::Vector3 result;
48856
48857   arg1 = (Dali::CameraActor *)jarg1;
48858   {
48859     try {
48860       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48861     } catch (std::out_of_range& e) {
48862       {
48863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48864       };
48865     } catch (std::exception& e) {
48866       {
48867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48868       };
48869     } catch (Dali::DaliException e) {
48870       {
48871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48872       };
48873     } catch (...) {
48874       {
48875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48876       };
48877     }
48878   }
48879
48880   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48881   return jresult;
48882 }
48883
48884
48885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48886   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48887   bool arg2 ;
48888
48889   arg1 = (Dali::CameraActor *)jarg1;
48890   arg2 = jarg2 ? true : false;
48891   {
48892     try {
48893       (arg1)->SetInvertYAxis(arg2);
48894     } catch (std::out_of_range& e) {
48895       {
48896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48897       };
48898     } catch (std::exception& e) {
48899       {
48900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48901       };
48902     } catch (Dali::DaliException e) {
48903       {
48904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48905       };
48906     } catch (...) {
48907       {
48908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48909       };
48910     }
48911   }
48912
48913 }
48914
48915
48916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48917   unsigned int jresult ;
48918   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48919   bool result;
48920
48921   arg1 = (Dali::CameraActor *)jarg1;
48922   {
48923     try {
48924       result = (bool)(arg1)->GetInvertYAxis();
48925     } catch (std::out_of_range& e) {
48926       {
48927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48928       };
48929     } catch (std::exception& e) {
48930       {
48931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48932       };
48933     } catch (Dali::DaliException e) {
48934       {
48935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48936       };
48937     } catch (...) {
48938       {
48939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48940       };
48941     }
48942   }
48943
48944   jresult = result;
48945   return jresult;
48946 }
48947
48948
48949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48950   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48951   Dali::Size *arg2 = 0 ;
48952
48953   arg1 = (Dali::CameraActor *)jarg1;
48954   arg2 = (Dali::Size *)jarg2;
48955   if (!arg2) {
48956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48957     return ;
48958   }
48959   {
48960     try {
48961       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48962     } catch (std::out_of_range& e) {
48963       {
48964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48965       };
48966     } catch (std::exception& e) {
48967       {
48968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48969       };
48970     } catch (Dali::DaliException e) {
48971       {
48972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48973       };
48974     } catch (...) {
48975       {
48976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48977       };
48978     }
48979   }
48980
48981 }
48982
48983
48984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48985   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48986   Dali::Size *arg2 = 0 ;
48987
48988   arg1 = (Dali::CameraActor *)jarg1;
48989   arg2 = (Dali::Size *)jarg2;
48990   if (!arg2) {
48991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48992     return ;
48993   }
48994   {
48995     try {
48996       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48997     } catch (std::out_of_range& e) {
48998       {
48999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49000       };
49001     } catch (std::exception& e) {
49002       {
49003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49004       };
49005     } catch (Dali::DaliException e) {
49006       {
49007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49008       };
49009     } catch (...) {
49010       {
49011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49012       };
49013     }
49014   }
49015
49016 }
49017
49018
49019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49020   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49021   float arg2 ;
49022   float arg3 ;
49023   float arg4 ;
49024   float arg5 ;
49025   float arg6 ;
49026   float arg7 ;
49027
49028   arg1 = (Dali::CameraActor *)jarg1;
49029   arg2 = (float)jarg2;
49030   arg3 = (float)jarg3;
49031   arg4 = (float)jarg4;
49032   arg5 = (float)jarg5;
49033   arg6 = (float)jarg6;
49034   arg7 = (float)jarg7;
49035   {
49036     try {
49037       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49038     } catch (std::out_of_range& e) {
49039       {
49040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49041       };
49042     } catch (std::exception& e) {
49043       {
49044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49045       };
49046     } catch (Dali::DaliException e) {
49047       {
49048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49049       };
49050     } catch (...) {
49051       {
49052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49053       };
49054     }
49055   }
49056
49057 }
49058
49059
49060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49061   void * jresult ;
49062   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49063
49064   {
49065     try {
49066       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49067     } catch (std::out_of_range& e) {
49068       {
49069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49070       };
49071     } catch (std::exception& e) {
49072       {
49073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49074       };
49075     } catch (Dali::DaliException e) {
49076       {
49077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49078       };
49079     } catch (...) {
49080       {
49081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49082       };
49083     }
49084   }
49085
49086   jresult = (void *)result;
49087   return jresult;
49088 }
49089
49090
49091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49092   void * jresult ;
49093   std::string arg1 ;
49094   Dali::Property::Value arg2 ;
49095   Dali::Property::Value *argp2 ;
49096   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49097
49098   if (!jarg1) {
49099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49100     return 0;
49101   }
49102   (&arg1)->assign(jarg1);
49103   argp2 = (Dali::Property::Value *)jarg2;
49104   if (!argp2) {
49105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49106     return 0;
49107   }
49108   arg2 = *argp2;
49109   {
49110     try {
49111       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49112     } catch (std::out_of_range& e) {
49113       {
49114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49115       };
49116     } catch (std::exception& e) {
49117       {
49118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49119       };
49120     } catch (Dali::DaliException e) {
49121       {
49122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49123       };
49124     } catch (...) {
49125       {
49126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49127       };
49128     }
49129   }
49130
49131   jresult = (void *)result;
49132   return jresult;
49133 }
49134
49135
49136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49137   void * jresult ;
49138   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49139   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49140
49141   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49142   if (!arg1) {
49143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49144     return 0;
49145   }
49146   {
49147     try {
49148       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >((std::pair< std::string,Dali::Property::Value > const &)*arg1);
49149     } catch (std::out_of_range& e) {
49150       {
49151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49152       };
49153     } catch (std::exception& e) {
49154       {
49155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49156       };
49157     } catch (Dali::DaliException e) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49160       };
49161     } catch (...) {
49162       {
49163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49164       };
49165     }
49166   }
49167
49168   jresult = (void *)result;
49169   return jresult;
49170 }
49171
49172
49173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49174   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49175   std::string *arg2 = 0 ;
49176
49177   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49178   if (!jarg2) {
49179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49180     return ;
49181   }
49182   std::string arg2_str(jarg2);
49183   arg2 = &arg2_str;
49184   if (arg1) (arg1)->first = *arg2;
49185
49186   //argout typemap for const std::string&
49187
49188 }
49189
49190
49191 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49192   char * jresult ;
49193   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49194   std::string *result = 0 ;
49195
49196   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49197   result = (std::string *) & ((arg1)->first);
49198   jresult = SWIG_csharp_string_callback(result->c_str());
49199   return jresult;
49200 }
49201
49202
49203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49204   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49205   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49206
49207   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49208   arg2 = (Dali::Property::Value *)jarg2;
49209   if (arg1) (arg1)->second = *arg2;
49210 }
49211
49212
49213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49214   void * jresult ;
49215   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49216   Dali::Property::Value *result = 0 ;
49217
49218   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49219   result = (Dali::Property::Value *)& ((arg1)->second);
49220   jresult = (void *)result;
49221   return jresult;
49222 }
49223
49224
49225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49226   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49227
49228   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49229   {
49230     try {
49231       delete arg1;
49232     } catch (std::out_of_range& e) {
49233       {
49234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49235       };
49236     } catch (std::exception& e) {
49237       {
49238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49239       };
49240     } catch (Dali::DaliException e) {
49241       {
49242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49243       };
49244     } catch (...) {
49245       {
49246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49247       };
49248     }
49249   }
49250
49251 }
49252
49253
49254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49255   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49256
49257   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49258   {
49259     try {
49260       (arg1)->clear();
49261     } catch (std::out_of_range& e) {
49262       {
49263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49264       };
49265     } catch (std::exception& e) {
49266       {
49267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49268       };
49269     } catch (Dali::DaliException e) {
49270       {
49271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49272       };
49273     } catch (...) {
49274       {
49275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49276       };
49277     }
49278   }
49279
49280 }
49281
49282
49283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49284   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49285   Dali::TouchPoint *arg2 = 0 ;
49286
49287   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49288   arg2 = (Dali::TouchPoint *)jarg2;
49289   if (!arg2) {
49290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49291     return ;
49292   }
49293   {
49294     try {
49295       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49296     } catch (std::out_of_range& e) {
49297       {
49298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49299       };
49300     } catch (std::exception& e) {
49301       {
49302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49303       };
49304     } catch (Dali::DaliException e) {
49305       {
49306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49307       };
49308     } catch (...) {
49309       {
49310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49311       };
49312     }
49313   }
49314
49315 }
49316
49317
49318 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49319   unsigned long jresult ;
49320   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49321   std::vector< Dali::TouchPoint >::size_type result;
49322
49323   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49324   {
49325     try {
49326       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49327     } catch (std::out_of_range& e) {
49328       {
49329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49330       };
49331     } catch (std::exception& e) {
49332       {
49333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49334       };
49335     } catch (Dali::DaliException e) {
49336       {
49337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49338       };
49339     } catch (...) {
49340       {
49341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49342       };
49343     }
49344   }
49345
49346   jresult = (unsigned long)result;
49347   return jresult;
49348 }
49349
49350
49351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49352   unsigned long jresult ;
49353   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49354   std::vector< Dali::TouchPoint >::size_type result;
49355
49356   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49357   {
49358     try {
49359       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49360     } catch (std::out_of_range& e) {
49361       {
49362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49363       };
49364     } catch (std::exception& e) {
49365       {
49366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49367       };
49368     } catch (Dali::DaliException e) {
49369       {
49370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49371       };
49372     } catch (...) {
49373       {
49374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49375       };
49376     }
49377   }
49378
49379   jresult = (unsigned long)result;
49380   return jresult;
49381 }
49382
49383
49384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49385   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49386   std::vector< Dali::TouchPoint >::size_type arg2 ;
49387
49388   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49389   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49390   {
49391     try {
49392       (arg1)->reserve(arg2);
49393     } catch (std::out_of_range& e) {
49394       {
49395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49396       };
49397     } catch (std::exception& e) {
49398       {
49399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49400       };
49401     } catch (Dali::DaliException e) {
49402       {
49403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49404       };
49405     } catch (...) {
49406       {
49407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49408       };
49409     }
49410   }
49411
49412 }
49413
49414
49415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49416   void * jresult ;
49417   std::vector< Dali::TouchPoint > *result = 0 ;
49418
49419   {
49420     try {
49421       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49422     } catch (std::out_of_range& e) {
49423       {
49424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49425       };
49426     } catch (std::exception& e) {
49427       {
49428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49429       };
49430     } catch (Dali::DaliException e) {
49431       {
49432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49433       };
49434     } catch (...) {
49435       {
49436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49437       };
49438     }
49439   }
49440
49441   jresult = (void *)result;
49442   return jresult;
49443 }
49444
49445
49446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49447   void * jresult ;
49448   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49449   std::vector< Dali::TouchPoint > *result = 0 ;
49450
49451   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49452   if (!arg1) {
49453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49454     return 0;
49455   }
49456   {
49457     try {
49458       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49459     } catch (std::out_of_range& e) {
49460       {
49461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49462       };
49463     } catch (std::exception& e) {
49464       {
49465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49466       };
49467     } catch (Dali::DaliException e) {
49468       {
49469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49470       };
49471     } catch (...) {
49472       {
49473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49474       };
49475     }
49476   }
49477
49478   jresult = (void *)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49484   void * jresult ;
49485   int arg1 ;
49486   std::vector< Dali::TouchPoint > *result = 0 ;
49487
49488   arg1 = (int)jarg1;
49489   {
49490     try {
49491       try {
49492         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49493       }
49494       catch(std::out_of_range &_e) {
49495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49496         return 0;
49497       }
49498
49499     } catch (std::out_of_range& e) {
49500       {
49501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49502       };
49503     } catch (std::exception& e) {
49504       {
49505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49506       };
49507     } catch (Dali::DaliException e) {
49508       {
49509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49510       };
49511     } catch (...) {
49512       {
49513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49514       };
49515     }
49516   }
49517
49518   jresult = (void *)result;
49519   return jresult;
49520 }
49521
49522
49523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49524   void * jresult ;
49525   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49526   int arg2 ;
49527   SwigValueWrapper< Dali::TouchPoint > result;
49528
49529   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49530   arg2 = (int)jarg2;
49531   {
49532     try {
49533       try {
49534         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49535       }
49536       catch(std::out_of_range &_e) {
49537         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49538         return 0;
49539       }
49540
49541     } catch (std::out_of_range& e) {
49542       {
49543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49544       };
49545     } catch (std::exception& e) {
49546       {
49547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49548       };
49549     } catch (Dali::DaliException e) {
49550       {
49551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49552       };
49553     } catch (...) {
49554       {
49555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49556       };
49557     }
49558   }
49559
49560   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49561   return jresult;
49562 }
49563
49564
49565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49566   void * jresult ;
49567   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49568   int arg2 ;
49569   Dali::TouchPoint *result = 0 ;
49570
49571   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49572   arg2 = (int)jarg2;
49573   {
49574     try {
49575       try {
49576         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49577       }
49578       catch(std::out_of_range &_e) {
49579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49580         return 0;
49581       }
49582
49583     } catch (std::out_of_range& e) {
49584       {
49585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49586       };
49587     } catch (std::exception& e) {
49588       {
49589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49590       };
49591     } catch (Dali::DaliException e) {
49592       {
49593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49594       };
49595     } catch (...) {
49596       {
49597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49598       };
49599     }
49600   }
49601
49602   jresult = (void *)result;
49603   return jresult;
49604 }
49605
49606
49607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49608   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49609   int arg2 ;
49610   Dali::TouchPoint *arg3 = 0 ;
49611
49612   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49613   arg2 = (int)jarg2;
49614   arg3 = (Dali::TouchPoint *)jarg3;
49615   if (!arg3) {
49616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49617     return ;
49618   }
49619   {
49620     try {
49621       try {
49622         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49623       }
49624       catch(std::out_of_range &_e) {
49625         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49626         return ;
49627       }
49628
49629     } catch (std::out_of_range& e) {
49630       {
49631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49632       };
49633     } catch (std::exception& e) {
49634       {
49635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49636       };
49637     } catch (Dali::DaliException e) {
49638       {
49639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49640       };
49641     } catch (...) {
49642       {
49643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49644       };
49645     }
49646   }
49647
49648 }
49649
49650
49651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49652   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49653   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49654
49655   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49656   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49657   if (!arg2) {
49658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49659     return ;
49660   }
49661   {
49662     try {
49663       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49664     } catch (std::out_of_range& e) {
49665       {
49666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49667       };
49668     } catch (std::exception& e) {
49669       {
49670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49671       };
49672     } catch (Dali::DaliException e) {
49673       {
49674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49675       };
49676     } catch (...) {
49677       {
49678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49679       };
49680     }
49681   }
49682
49683 }
49684
49685
49686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49687   void * jresult ;
49688   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49689   int arg2 ;
49690   int arg3 ;
49691   std::vector< Dali::TouchPoint > *result = 0 ;
49692
49693   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49694   arg2 = (int)jarg2;
49695   arg3 = (int)jarg3;
49696   {
49697     try {
49698       try {
49699         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49700       }
49701       catch(std::out_of_range &_e) {
49702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49703         return 0;
49704       }
49705       catch(std::invalid_argument &_e) {
49706         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49707         return 0;
49708       }
49709
49710     } catch (std::out_of_range& e) {
49711       {
49712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49713       };
49714     } catch (std::exception& e) {
49715       {
49716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49717       };
49718     } catch (Dali::DaliException e) {
49719       {
49720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49721       };
49722     } catch (...) {
49723       {
49724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49725       };
49726     }
49727   }
49728
49729   jresult = (void *)result;
49730   return jresult;
49731 }
49732
49733
49734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49735   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49736   int arg2 ;
49737   Dali::TouchPoint *arg3 = 0 ;
49738
49739   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49740   arg2 = (int)jarg2;
49741   arg3 = (Dali::TouchPoint *)jarg3;
49742   if (!arg3) {
49743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49744     return ;
49745   }
49746   {
49747     try {
49748       try {
49749         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49750       }
49751       catch(std::out_of_range &_e) {
49752         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49753         return ;
49754       }
49755
49756     } catch (std::out_of_range& e) {
49757       {
49758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (std::exception& e) {
49761       {
49762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (Dali::DaliException e) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49767       };
49768     } catch (...) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49771       };
49772     }
49773   }
49774
49775 }
49776
49777
49778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49779   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49780   int arg2 ;
49781   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49782
49783   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49784   arg2 = (int)jarg2;
49785   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49786   if (!arg3) {
49787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49788     return ;
49789   }
49790   {
49791     try {
49792       try {
49793         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49794       }
49795       catch(std::out_of_range &_e) {
49796         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49797         return ;
49798       }
49799
49800     } catch (std::out_of_range& e) {
49801       {
49802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49803       };
49804     } catch (std::exception& e) {
49805       {
49806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49807       };
49808     } catch (Dali::DaliException e) {
49809       {
49810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49811       };
49812     } catch (...) {
49813       {
49814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49815       };
49816     }
49817   }
49818
49819 }
49820
49821
49822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49823   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49824   int arg2 ;
49825
49826   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49827   arg2 = (int)jarg2;
49828   {
49829     try {
49830       try {
49831         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49832       }
49833       catch(std::out_of_range &_e) {
49834         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49835         return ;
49836       }
49837
49838     } catch (std::out_of_range& e) {
49839       {
49840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49841       };
49842     } catch (std::exception& e) {
49843       {
49844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49845       };
49846     } catch (Dali::DaliException e) {
49847       {
49848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49849       };
49850     } catch (...) {
49851       {
49852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49853       };
49854     }
49855   }
49856
49857 }
49858
49859
49860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49861   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49862   int arg2 ;
49863   int arg3 ;
49864
49865   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49866   arg2 = (int)jarg2;
49867   arg3 = (int)jarg3;
49868   {
49869     try {
49870       try {
49871         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49872       }
49873       catch(std::out_of_range &_e) {
49874         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49875         return ;
49876       }
49877       catch(std::invalid_argument &_e) {
49878         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49879         return ;
49880       }
49881
49882     } catch (std::out_of_range& e) {
49883       {
49884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49885       };
49886     } catch (std::exception& e) {
49887       {
49888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49889       };
49890     } catch (Dali::DaliException e) {
49891       {
49892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49893       };
49894     } catch (...) {
49895       {
49896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49897       };
49898     }
49899   }
49900
49901 }
49902
49903
49904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49905   void * jresult ;
49906   Dali::TouchPoint *arg1 = 0 ;
49907   int arg2 ;
49908   std::vector< Dali::TouchPoint > *result = 0 ;
49909
49910   arg1 = (Dali::TouchPoint *)jarg1;
49911   if (!arg1) {
49912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49913     return 0;
49914   }
49915   arg2 = (int)jarg2;
49916   {
49917     try {
49918       try {
49919         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49920       }
49921       catch(std::out_of_range &_e) {
49922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49923         return 0;
49924       }
49925
49926     } catch (std::out_of_range& e) {
49927       {
49928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49929       };
49930     } catch (std::exception& e) {
49931       {
49932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49933       };
49934     } catch (Dali::DaliException e) {
49935       {
49936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49937       };
49938     } catch (...) {
49939       {
49940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49941       };
49942     }
49943   }
49944
49945   jresult = (void *)result;
49946   return jresult;
49947 }
49948
49949
49950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49951   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49952
49953   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49954   {
49955     try {
49956       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (Dali::DaliException e) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49968       };
49969     } catch (...) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49972       };
49973     }
49974   }
49975
49976 }
49977
49978
49979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49980   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49981   int arg2 ;
49982   int arg3 ;
49983
49984   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49985   arg2 = (int)jarg2;
49986   arg3 = (int)jarg3;
49987   {
49988     try {
49989       try {
49990         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49991       }
49992       catch(std::out_of_range &_e) {
49993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49994         return ;
49995       }
49996       catch(std::invalid_argument &_e) {
49997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49998         return ;
49999       }
50000
50001     } catch (std::out_of_range& e) {
50002       {
50003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50004       };
50005     } catch (std::exception& e) {
50006       {
50007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50008       };
50009     } catch (Dali::DaliException e) {
50010       {
50011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50012       };
50013     } catch (...) {
50014       {
50015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50016       };
50017     }
50018   }
50019
50020 }
50021
50022
50023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50024   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50025   int arg2 ;
50026   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50027
50028   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50029   arg2 = (int)jarg2;
50030   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50031   if (!arg3) {
50032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50033     return ;
50034   }
50035   {
50036     try {
50037       try {
50038         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50039       }
50040       catch(std::out_of_range &_e) {
50041         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50042         return ;
50043       }
50044
50045     } catch (std::out_of_range& e) {
50046       {
50047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50048       };
50049     } catch (std::exception& e) {
50050       {
50051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50052       };
50053     } catch (Dali::DaliException e) {
50054       {
50055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50056       };
50057     } catch (...) {
50058       {
50059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50060       };
50061     }
50062   }
50063
50064 }
50065
50066
50067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50068   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50069
50070   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50071   {
50072     try {
50073       delete arg1;
50074     } catch (std::out_of_range& e) {
50075       {
50076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50077       };
50078     } catch (std::exception& e) {
50079       {
50080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50081       };
50082     } catch (Dali::DaliException e) {
50083       {
50084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50085       };
50086     } catch (...) {
50087       {
50088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50089       };
50090     }
50091   }
50092
50093 }
50094
50095
50096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50097   void * jresult ;
50098   Dali::Rect< int > *result = 0 ;
50099
50100   {
50101     try {
50102       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50103     } catch (std::out_of_range& e) {
50104       {
50105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50106       };
50107     } catch (std::exception& e) {
50108       {
50109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50110       };
50111     } catch (Dali::DaliException e) {
50112       {
50113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50114       };
50115     } catch (...) {
50116       {
50117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50118       };
50119     }
50120   }
50121
50122   jresult = (void *)result;
50123   return jresult;
50124 }
50125
50126
50127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50128   void * jresult ;
50129   int arg1 ;
50130   int arg2 ;
50131   int arg3 ;
50132   int arg4 ;
50133   Dali::Rect< int > *result = 0 ;
50134
50135   arg1 = (int)jarg1;
50136   arg2 = (int)jarg2;
50137   arg3 = (int)jarg3;
50138   arg4 = (int)jarg4;
50139   {
50140     try {
50141       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50142     } catch (std::out_of_range& e) {
50143       {
50144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50145       };
50146     } catch (std::exception& e) {
50147       {
50148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50149       };
50150     } catch (Dali::DaliException e) {
50151       {
50152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50153       };
50154     } catch (...) {
50155       {
50156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50157       };
50158     }
50159   }
50160
50161   jresult = (void *)result;
50162   return jresult;
50163 }
50164
50165
50166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50167   void * jresult ;
50168   Dali::Rect< int > *arg1 = 0 ;
50169   Dali::Rect< int > *result = 0 ;
50170
50171   arg1 = (Dali::Rect< int > *)jarg1;
50172   if (!arg1) {
50173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50174     return 0;
50175   }
50176   {
50177     try {
50178       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50179     } catch (std::out_of_range& e) {
50180       {
50181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50182       };
50183     } catch (std::exception& e) {
50184       {
50185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50186       };
50187     } catch (Dali::DaliException e) {
50188       {
50189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50190       };
50191     } catch (...) {
50192       {
50193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50194       };
50195     }
50196   }
50197
50198   jresult = (void *)result;
50199   return jresult;
50200 }
50201
50202
50203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50204   void * jresult ;
50205   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50206   Dali::Rect< int > *arg2 = 0 ;
50207   Dali::Rect< int > *result = 0 ;
50208
50209   arg1 = (Dali::Rect< int > *)jarg1;
50210   arg2 = (Dali::Rect< int > *)jarg2;
50211   if (!arg2) {
50212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50213     return 0;
50214   }
50215   {
50216     try {
50217       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50218     } catch (std::out_of_range& e) {
50219       {
50220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50221       };
50222     } catch (std::exception& e) {
50223       {
50224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50225       };
50226     } catch (Dali::DaliException e) {
50227       {
50228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50229       };
50230     } catch (...) {
50231       {
50232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50233       };
50234     }
50235   }
50236
50237   jresult = (void *)result;
50238   return jresult;
50239 }
50240
50241
50242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50243   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50244   int arg2 ;
50245   int arg3 ;
50246   int arg4 ;
50247   int arg5 ;
50248
50249   arg1 = (Dali::Rect< int > *)jarg1;
50250   arg2 = (int)jarg2;
50251   arg3 = (int)jarg3;
50252   arg4 = (int)jarg4;
50253   arg5 = (int)jarg5;
50254   {
50255     try {
50256       (arg1)->Set(arg2,arg3,arg4,arg5);
50257     } catch (std::out_of_range& e) {
50258       {
50259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50260       };
50261     } catch (std::exception& e) {
50262       {
50263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50264       };
50265     } catch (Dali::DaliException e) {
50266       {
50267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50268       };
50269     } catch (...) {
50270       {
50271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50272       };
50273     }
50274   }
50275
50276 }
50277
50278
50279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50280   unsigned int jresult ;
50281   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50282   bool result;
50283
50284   arg1 = (Dali::Rect< int > *)jarg1;
50285   {
50286     try {
50287       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50288     } catch (std::out_of_range& e) {
50289       {
50290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50291       };
50292     } catch (std::exception& e) {
50293       {
50294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50295       };
50296     } catch (Dali::DaliException e) {
50297       {
50298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50299       };
50300     } catch (...) {
50301       {
50302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50303       };
50304     }
50305   }
50306
50307   jresult = result;
50308   return jresult;
50309 }
50310
50311
50312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50313   int jresult ;
50314   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50315   int result;
50316
50317   arg1 = (Dali::Rect< int > *)jarg1;
50318   {
50319     try {
50320       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50321     } catch (std::out_of_range& e) {
50322       {
50323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50324       };
50325     } catch (std::exception& e) {
50326       {
50327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50328       };
50329     } catch (Dali::DaliException e) {
50330       {
50331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50332       };
50333     } catch (...) {
50334       {
50335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50336       };
50337     }
50338   }
50339
50340   jresult = result;
50341   return jresult;
50342 }
50343
50344
50345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50346   int jresult ;
50347   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50348   int result;
50349
50350   arg1 = (Dali::Rect< int > *)jarg1;
50351   {
50352     try {
50353       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50354     } catch (std::out_of_range& e) {
50355       {
50356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50357       };
50358     } catch (std::exception& e) {
50359       {
50360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50361       };
50362     } catch (Dali::DaliException e) {
50363       {
50364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50365       };
50366     } catch (...) {
50367       {
50368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50369       };
50370     }
50371   }
50372
50373   jresult = result;
50374   return jresult;
50375 }
50376
50377
50378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50379   int jresult ;
50380   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50381   int result;
50382
50383   arg1 = (Dali::Rect< int > *)jarg1;
50384   {
50385     try {
50386       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50387     } catch (std::out_of_range& e) {
50388       {
50389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50390       };
50391     } catch (std::exception& e) {
50392       {
50393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50394       };
50395     } catch (Dali::DaliException e) {
50396       {
50397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50398       };
50399     } catch (...) {
50400       {
50401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50402       };
50403     }
50404   }
50405
50406   jresult = result;
50407   return jresult;
50408 }
50409
50410
50411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50412   int jresult ;
50413   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50414   int result;
50415
50416   arg1 = (Dali::Rect< int > *)jarg1;
50417   {
50418     try {
50419       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50420     } catch (std::out_of_range& e) {
50421       {
50422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50423       };
50424     } catch (std::exception& e) {
50425       {
50426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50427       };
50428     } catch (Dali::DaliException e) {
50429       {
50430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50431       };
50432     } catch (...) {
50433       {
50434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50435       };
50436     }
50437   }
50438
50439   jresult = result;
50440   return jresult;
50441 }
50442
50443
50444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50445   int jresult ;
50446   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50447   int result;
50448
50449   arg1 = (Dali::Rect< int > *)jarg1;
50450   {
50451     try {
50452       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50453     } catch (std::out_of_range& e) {
50454       {
50455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50456       };
50457     } catch (std::exception& e) {
50458       {
50459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50460       };
50461     } catch (Dali::DaliException e) {
50462       {
50463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50464       };
50465     } catch (...) {
50466       {
50467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50468       };
50469     }
50470   }
50471
50472   jresult = result;
50473   return jresult;
50474 }
50475
50476
50477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50478   unsigned int jresult ;
50479   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50480   Dali::Rect< int > *arg2 = 0 ;
50481   bool result;
50482
50483   arg1 = (Dali::Rect< int > *)jarg1;
50484   arg2 = (Dali::Rect< int > *)jarg2;
50485   if (!arg2) {
50486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50487     return 0;
50488   }
50489   {
50490     try {
50491       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50492     } catch (std::out_of_range& e) {
50493       {
50494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50495       };
50496     } catch (std::exception& e) {
50497       {
50498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50499       };
50500     } catch (Dali::DaliException e) {
50501       {
50502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50503       };
50504     } catch (...) {
50505       {
50506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50507       };
50508     }
50509   }
50510
50511   jresult = result;
50512   return jresult;
50513 }
50514
50515
50516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50517   unsigned int jresult ;
50518   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50519   Dali::Rect< int > *arg2 = 0 ;
50520   bool result;
50521
50522   arg1 = (Dali::Rect< int > *)jarg1;
50523   arg2 = (Dali::Rect< int > *)jarg2;
50524   if (!arg2) {
50525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50526     return 0;
50527   }
50528   {
50529     try {
50530       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50531     } catch (std::out_of_range& e) {
50532       {
50533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50534       };
50535     } catch (std::exception& e) {
50536       {
50537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50538       };
50539     } catch (Dali::DaliException e) {
50540       {
50541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50542       };
50543     } catch (...) {
50544       {
50545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50546       };
50547     }
50548   }
50549
50550   jresult = result;
50551   return jresult;
50552 }
50553
50554
50555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50556   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50557   int arg2 ;
50558
50559   arg1 = (Dali::Rect< int > *)jarg1;
50560   arg2 = (int)jarg2;
50561   if (arg1) (arg1)->x = arg2;
50562 }
50563
50564
50565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50566   int jresult ;
50567   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50568   int result;
50569
50570   arg1 = (Dali::Rect< int > *)jarg1;
50571   result = (int) ((arg1)->x);
50572   jresult = result;
50573   return jresult;
50574 }
50575
50576
50577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50578   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50579   int arg2 ;
50580
50581   arg1 = (Dali::Rect< int > *)jarg1;
50582   arg2 = (int)jarg2;
50583   if (arg1) (arg1)->left = arg2;
50584 }
50585
50586
50587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50588   int jresult ;
50589   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50590   int result;
50591
50592   arg1 = (Dali::Rect< int > *)jarg1;
50593   result = (int) ((arg1)->left);
50594   jresult = result;
50595   return jresult;
50596 }
50597
50598
50599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50600   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50601   int arg2 ;
50602
50603   arg1 = (Dali::Rect< int > *)jarg1;
50604   arg2 = (int)jarg2;
50605   if (arg1) (arg1)->y = arg2;
50606 }
50607
50608
50609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50610   int jresult ;
50611   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50612   int result;
50613
50614   arg1 = (Dali::Rect< int > *)jarg1;
50615   result = (int) ((arg1)->y);
50616   jresult = result;
50617   return jresult;
50618 }
50619
50620
50621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50622   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50623   int arg2 ;
50624
50625   arg1 = (Dali::Rect< int > *)jarg1;
50626   arg2 = (int)jarg2;
50627   if (arg1) (arg1)->right = arg2;
50628 }
50629
50630
50631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50632   int jresult ;
50633   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50634   int result;
50635
50636   arg1 = (Dali::Rect< int > *)jarg1;
50637   result = (int) ((arg1)->right);
50638   jresult = result;
50639   return jresult;
50640 }
50641
50642
50643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50644   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50645   int arg2 ;
50646
50647   arg1 = (Dali::Rect< int > *)jarg1;
50648   arg2 = (int)jarg2;
50649   if (arg1) (arg1)->width = arg2;
50650 }
50651
50652
50653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50654   int jresult ;
50655   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50656   int result;
50657
50658   arg1 = (Dali::Rect< int > *)jarg1;
50659   result = (int) ((arg1)->width);
50660   jresult = result;
50661   return jresult;
50662 }
50663
50664
50665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50666   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50667   int arg2 ;
50668
50669   arg1 = (Dali::Rect< int > *)jarg1;
50670   arg2 = (int)jarg2;
50671   if (arg1) (arg1)->bottom = arg2;
50672 }
50673
50674
50675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50676   int jresult ;
50677   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50678   int result;
50679
50680   arg1 = (Dali::Rect< int > *)jarg1;
50681   result = (int) ((arg1)->bottom);
50682   jresult = result;
50683   return jresult;
50684 }
50685
50686
50687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50688   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50689   int arg2 ;
50690
50691   arg1 = (Dali::Rect< int > *)jarg1;
50692   arg2 = (int)jarg2;
50693   if (arg1) (arg1)->height = arg2;
50694 }
50695
50696
50697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50698   int jresult ;
50699   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50700   int result;
50701
50702   arg1 = (Dali::Rect< int > *)jarg1;
50703   result = (int) ((arg1)->height);
50704   jresult = result;
50705   return jresult;
50706 }
50707
50708
50709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50710   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50711   int arg2 ;
50712
50713   arg1 = (Dali::Rect< int > *)jarg1;
50714   arg2 = (int)jarg2;
50715   if (arg1) (arg1)->top = arg2;
50716 }
50717
50718
50719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50720   int jresult ;
50721   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50722   int result;
50723
50724   arg1 = (Dali::Rect< int > *)jarg1;
50725   result = (int) ((arg1)->top);
50726   jresult = result;
50727   return jresult;
50728 }
50729
50730
50731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50732   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50733
50734   arg1 = (Dali::Rect< int > *)jarg1;
50735   {
50736     try {
50737       delete arg1;
50738     } catch (std::out_of_range& e) {
50739       {
50740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50741       };
50742     } catch (std::exception& e) {
50743       {
50744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50745       };
50746     } catch (Dali::DaliException e) {
50747       {
50748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50749       };
50750     } catch (...) {
50751       {
50752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50753       };
50754     }
50755   }
50756
50757 }
50758
50759
50760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50761   void * jresult ;
50762   Dali::Rect< float > *result = 0 ;
50763
50764   {
50765     try {
50766       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50767     } catch (std::out_of_range& e) {
50768       {
50769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (std::exception& e) {
50772       {
50773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50774       };
50775     } catch (Dali::DaliException e) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50778       };
50779     } catch (...) {
50780       {
50781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50782       };
50783     }
50784   }
50785
50786   jresult = (void *)result;
50787   return jresult;
50788 }
50789
50790
50791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50792   void * jresult ;
50793   float arg1 ;
50794   float arg2 ;
50795   float arg3 ;
50796   float arg4 ;
50797   Dali::Rect< float > *result = 0 ;
50798
50799   arg1 = (float)jarg1;
50800   arg2 = (float)jarg2;
50801   arg3 = (float)jarg4;
50802   arg4 = (float)jarg3;
50803   {
50804     try {
50805       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50806     } catch (std::out_of_range& e) {
50807       {
50808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50809       };
50810     } catch (std::exception& e) {
50811       {
50812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50813       };
50814     } catch (Dali::DaliException e) {
50815       {
50816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50817       };
50818     } catch (...) {
50819       {
50820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50821       };
50822     }
50823   }
50824
50825   jresult = (void *)result;
50826   return jresult;
50827 }
50828
50829
50830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50831   void * jresult ;
50832   Dali::Rect< float > *arg1 = 0 ;
50833   Dali::Rect< float > *result = 0 ;
50834
50835   arg1 = (Dali::Rect< float > *)jarg1;
50836   if (!arg1) {
50837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50838     return 0;
50839   }
50840   {
50841     try {
50842       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50843     } catch (std::out_of_range& e) {
50844       {
50845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50846       };
50847     } catch (std::exception& e) {
50848       {
50849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50850       };
50851     } catch (Dali::DaliException e) {
50852       {
50853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50854       };
50855     } catch (...) {
50856       {
50857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50858       };
50859     }
50860   }
50861
50862   jresult = (void *)result;
50863   return jresult;
50864 }
50865
50866
50867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50868   void * jresult ;
50869   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50870   Dali::Rect< float > *arg2 = 0 ;
50871   Dali::Rect< float > *result = 0 ;
50872
50873   arg1 = (Dali::Rect< float > *)jarg1;
50874   arg2 = (Dali::Rect< float > *)jarg2;
50875   if (!arg2) {
50876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50877     return 0;
50878   }
50879   {
50880     try {
50881       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50882     } catch (std::out_of_range& e) {
50883       {
50884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50885       };
50886     } catch (std::exception& e) {
50887       {
50888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50889       };
50890     } catch (Dali::DaliException e) {
50891       {
50892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50893       };
50894     } catch (...) {
50895       {
50896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50897       };
50898     }
50899   }
50900
50901   jresult = (void *)result;
50902   return jresult;
50903 }
50904
50905
50906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50907   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50908   float arg2 ;
50909   float arg3 ;
50910   float arg4 ;
50911   float arg5 ;
50912
50913   arg1 = (Dali::Rect< float > *)jarg1;
50914   arg2 = (float)jarg2;
50915   arg3 = (float)jarg3;
50916   arg4 = (float)jarg5;
50917   arg5 = (float)jarg4;
50918   {
50919     try {
50920       (arg1)->Set(arg2,arg3,arg4,arg5);
50921     } catch (std::out_of_range& e) {
50922       {
50923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50924       };
50925     } catch (std::exception& e) {
50926       {
50927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50928       };
50929     } catch (Dali::DaliException e) {
50930       {
50931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50932       };
50933     } catch (...) {
50934       {
50935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50936       };
50937     }
50938   }
50939
50940 }
50941
50942
50943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50944   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50945   float arg2 ;
50946
50947   arg1 = (Dali::Rect< float > *)jarg1;
50948   arg2 = (float)jarg2;
50949   if (arg1) (arg1)->left = arg2;
50950 }
50951
50952
50953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50954   float jresult ;
50955   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50956   float result;
50957
50958   arg1 = (Dali::Rect< float > *)jarg1;
50959   result = (float) ((arg1)->left);
50960   jresult = result;
50961   return jresult;
50962 }
50963
50964
50965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50966   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50967   float arg2 ;
50968
50969   arg1 = (Dali::Rect< float > *)jarg1;
50970   arg2 = (float)jarg2;
50971   if (arg1) (arg1)->left = arg2;
50972 }
50973
50974
50975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50976   float jresult ;
50977   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50978   float result;
50979
50980   arg1 = (Dali::Rect< float > *)jarg1;
50981   result = (float) ((arg1)->left);
50982   jresult = result;
50983   return jresult;
50984 }
50985
50986
50987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50988   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50989   float arg2 ;
50990
50991   arg1 = (Dali::Rect< float > *)jarg1;
50992   arg2 = (float)jarg2;
50993   if (arg1) (arg1)->right = arg2;
50994 }
50995
50996
50997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50998   float jresult ;
50999   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51000   float result;
51001
51002   arg1 = (Dali::Rect< float > *)jarg1;
51003   result = (float) ((arg1)->right);
51004   jresult = result;
51005   return jresult;
51006 }
51007
51008
51009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51010   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51011   float arg2 ;
51012
51013   arg1 = (Dali::Rect< float > *)jarg1;
51014   arg2 = (float)jarg2;
51015   if (arg1) (arg1)->right = arg2;
51016 }
51017
51018
51019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51020   float jresult ;
51021   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51022   float result;
51023
51024   arg1 = (Dali::Rect< float > *)jarg1;
51025   result = (float) ((arg1)->right);
51026   jresult = result;
51027   return jresult;
51028 }
51029
51030
51031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51032   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51033   float arg2 ;
51034
51035   arg1 = (Dali::Rect< float > *)jarg1;
51036   arg2 = (float)jarg2;
51037   if (arg1) (arg1)->bottom = arg2;
51038 }
51039
51040
51041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51042   float jresult ;
51043   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51044   float result;
51045
51046   arg1 = (Dali::Rect< float > *)jarg1;
51047   result = (float) ((arg1)->bottom);
51048   jresult = result;
51049   return jresult;
51050 }
51051
51052
51053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51054   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51055   float arg2 ;
51056
51057   arg1 = (Dali::Rect< float > *)jarg1;
51058   arg2 = (float)jarg2;
51059   if (arg1) (arg1)->top = arg2;
51060 }
51061
51062
51063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51064   float jresult ;
51065   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51066   float result;
51067
51068   arg1 = (Dali::Rect< float > *)jarg1;
51069   result = (float) ((arg1)->top);
51070   jresult = result;
51071   return jresult;
51072 }
51073
51074
51075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51076   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51077
51078   arg1 = (Dali::Rect< float > *)jarg1;
51079   {
51080     try {
51081       delete arg1;
51082     } catch (std::out_of_range& e) {
51083       {
51084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51085       };
51086     } catch (std::exception& e) {
51087       {
51088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51089       };
51090     } catch (Dali::DaliException e) {
51091       {
51092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51093       };
51094     } catch (...) {
51095       {
51096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51097       };
51098     }
51099   }
51100
51101 }
51102
51103
51104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51105   int jresult ;
51106   int result;
51107
51108   result = (int)Dali::Vector< int >::BaseType;
51109   jresult = (int)result;
51110   return jresult;
51111 }
51112
51113
51114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51115   void * jresult ;
51116   Dali::Vector< int > *result = 0 ;
51117
51118   {
51119     try {
51120       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51121     } catch (std::out_of_range& e) {
51122       {
51123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51124       };
51125     } catch (std::exception& e) {
51126       {
51127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51128       };
51129     } catch (Dali::DaliException e) {
51130       {
51131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51132       };
51133     } catch (...) {
51134       {
51135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51136       };
51137     }
51138   }
51139
51140   jresult = (void *)result;
51141   return jresult;
51142 }
51143
51144
51145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51146   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51147
51148   arg1 = (Dali::Vector< int > *)jarg1;
51149   {
51150     try {
51151       delete arg1;
51152     } catch (std::out_of_range& e) {
51153       {
51154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51155       };
51156     } catch (std::exception& e) {
51157       {
51158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51159       };
51160     } catch (Dali::DaliException e) {
51161       {
51162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51163       };
51164     } catch (...) {
51165       {
51166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51167       };
51168     }
51169   }
51170
51171 }
51172
51173
51174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51175   void * jresult ;
51176   Dali::Vector< int > *arg1 = 0 ;
51177   Dali::Vector< int > *result = 0 ;
51178
51179   arg1 = (Dali::Vector< int > *)jarg1;
51180   if (!arg1) {
51181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51182     return 0;
51183   }
51184   {
51185     try {
51186       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51187     } catch (std::out_of_range& e) {
51188       {
51189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51190       };
51191     } catch (std::exception& e) {
51192       {
51193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51194       };
51195     } catch (Dali::DaliException e) {
51196       {
51197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51198       };
51199     } catch (...) {
51200       {
51201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51202       };
51203     }
51204   }
51205
51206   jresult = (void *)result;
51207   return jresult;
51208 }
51209
51210
51211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51212   void * jresult ;
51213   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51214   Dali::Vector< int > *arg2 = 0 ;
51215   Dali::Vector< int > *result = 0 ;
51216
51217   arg1 = (Dali::Vector< int > *)jarg1;
51218   arg2 = (Dali::Vector< int > *)jarg2;
51219   if (!arg2) {
51220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51221     return 0;
51222   }
51223   {
51224     try {
51225       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51226     } catch (std::out_of_range& e) {
51227       {
51228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51229       };
51230     } catch (std::exception& e) {
51231       {
51232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51233       };
51234     } catch (Dali::DaliException e) {
51235       {
51236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51237       };
51238     } catch (...) {
51239       {
51240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51241       };
51242     }
51243   }
51244
51245   jresult = (void *)result;
51246   return jresult;
51247 }
51248
51249
51250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51251   void * jresult ;
51252   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51253   Dali::Vector< int >::Iterator result;
51254
51255   arg1 = (Dali::Vector< int > *)jarg1;
51256   {
51257     try {
51258       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51259     } catch (std::out_of_range& e) {
51260       {
51261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51262       };
51263     } catch (std::exception& e) {
51264       {
51265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51266       };
51267     } catch (Dali::DaliException e) {
51268       {
51269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51270       };
51271     } catch (...) {
51272       {
51273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51274       };
51275     }
51276   }
51277
51278   jresult = (void *)result;
51279   return jresult;
51280 }
51281
51282
51283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51284   void * jresult ;
51285   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51286   Dali::Vector< int >::Iterator result;
51287
51288   arg1 = (Dali::Vector< int > *)jarg1;
51289   {
51290     try {
51291       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51292     } catch (std::out_of_range& e) {
51293       {
51294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51295       };
51296     } catch (std::exception& e) {
51297       {
51298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51299       };
51300     } catch (Dali::DaliException e) {
51301       {
51302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51303       };
51304     } catch (...) {
51305       {
51306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51307       };
51308     }
51309   }
51310
51311   jresult = (void *)result;
51312   return jresult;
51313 }
51314
51315
51316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51317   void * jresult ;
51318   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51319   Dali::Vector< int >::SizeType arg2 ;
51320   Dali::Vector< int >::ItemType *result = 0 ;
51321
51322   arg1 = (Dali::Vector< int > *)jarg1;
51323   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51324   {
51325     try {
51326       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51327     } catch (std::out_of_range& e) {
51328       {
51329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51330       };
51331     } catch (std::exception& e) {
51332       {
51333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51334       };
51335     } catch (Dali::DaliException e) {
51336       {
51337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51338       };
51339     } catch (...) {
51340       {
51341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51342       };
51343     }
51344   }
51345
51346   jresult = (void *)result;
51347   return jresult;
51348 }
51349
51350
51351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51352   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51353   Dali::Vector< int >::ItemType *arg2 = 0 ;
51354   Dali::Vector< int >::ItemType temp2 ;
51355
51356   arg1 = (Dali::Vector< int > *)jarg1;
51357   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51358   arg2 = &temp2;
51359   {
51360     try {
51361       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51362     } catch (std::out_of_range& e) {
51363       {
51364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51365       };
51366     } catch (std::exception& e) {
51367       {
51368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51369       };
51370     } catch (Dali::DaliException e) {
51371       {
51372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51373       };
51374     } catch (...) {
51375       {
51376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51377       };
51378     }
51379   }
51380
51381 }
51382
51383
51384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51385   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51386   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51387   Dali::Vector< int >::ItemType *arg3 = 0 ;
51388   Dali::Vector< int >::ItemType temp3 ;
51389
51390   arg1 = (Dali::Vector< int > *)jarg1;
51391   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51392   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51393   arg3 = &temp3;
51394   {
51395     try {
51396       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51397     } catch (std::out_of_range& e) {
51398       {
51399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51400       };
51401     } catch (std::exception& e) {
51402       {
51403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51404       };
51405     } catch (Dali::DaliException e) {
51406       {
51407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51408       };
51409     } catch (...) {
51410       {
51411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51412       };
51413     }
51414   }
51415
51416 }
51417
51418
51419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51420   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51421   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51422   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51423   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51424
51425   arg1 = (Dali::Vector< int > *)jarg1;
51426   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51427   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51428   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51429   {
51430     try {
51431       (arg1)->Insert(arg2,arg3,arg4);
51432     } catch (std::out_of_range& e) {
51433       {
51434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51435       };
51436     } catch (std::exception& e) {
51437       {
51438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51439       };
51440     } catch (Dali::DaliException e) {
51441       {
51442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51443       };
51444     } catch (...) {
51445       {
51446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51447       };
51448     }
51449   }
51450
51451 }
51452
51453
51454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51455   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51456   Dali::Vector< int >::SizeType arg2 ;
51457
51458   arg1 = (Dali::Vector< int > *)jarg1;
51459   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51460   {
51461     try {
51462       (arg1)->Reserve(arg2);
51463     } catch (std::out_of_range& e) {
51464       {
51465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51466       };
51467     } catch (std::exception& e) {
51468       {
51469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51470       };
51471     } catch (Dali::DaliException e) {
51472       {
51473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51474       };
51475     } catch (...) {
51476       {
51477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51478       };
51479     }
51480   }
51481
51482 }
51483
51484
51485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51486   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51487   Dali::Vector< int >::SizeType arg2 ;
51488
51489   arg1 = (Dali::Vector< int > *)jarg1;
51490   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51491   {
51492     try {
51493       (arg1)->Resize(arg2);
51494     } catch (std::out_of_range& e) {
51495       {
51496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51497       };
51498     } catch (std::exception& e) {
51499       {
51500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51501       };
51502     } catch (Dali::DaliException e) {
51503       {
51504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51505       };
51506     } catch (...) {
51507       {
51508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51509       };
51510     }
51511   }
51512
51513 }
51514
51515
51516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51517   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51518   Dali::Vector< int >::SizeType arg2 ;
51519   Dali::Vector< int >::ItemType *arg3 = 0 ;
51520   Dali::Vector< int >::ItemType temp3 ;
51521
51522   arg1 = (Dali::Vector< int > *)jarg1;
51523   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51524   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51525   arg3 = &temp3;
51526   {
51527     try {
51528       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51529     } catch (std::out_of_range& e) {
51530       {
51531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51532       };
51533     } catch (std::exception& e) {
51534       {
51535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51536       };
51537     } catch (Dali::DaliException e) {
51538       {
51539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51540       };
51541     } catch (...) {
51542       {
51543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51544       };
51545     }
51546   }
51547
51548 }
51549
51550
51551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51552   void * jresult ;
51553   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51554   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51555   Dali::Vector< int >::Iterator result;
51556
51557   arg1 = (Dali::Vector< int > *)jarg1;
51558   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51559   {
51560     try {
51561       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51562     } catch (std::out_of_range& e) {
51563       {
51564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51565       };
51566     } catch (std::exception& e) {
51567       {
51568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51569       };
51570     } catch (Dali::DaliException e) {
51571       {
51572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51573       };
51574     } catch (...) {
51575       {
51576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51577       };
51578     }
51579   }
51580
51581   jresult = (void *)result;
51582   return jresult;
51583 }
51584
51585
51586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51587   void * jresult ;
51588   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51589   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51590   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51591   Dali::Vector< int >::Iterator result;
51592
51593   arg1 = (Dali::Vector< int > *)jarg1;
51594   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51595   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51596   {
51597     try {
51598       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51599     } catch (std::out_of_range& e) {
51600       {
51601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51602       };
51603     } catch (std::exception& e) {
51604       {
51605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51606       };
51607     } catch (Dali::DaliException e) {
51608       {
51609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51610       };
51611     } catch (...) {
51612       {
51613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51614       };
51615     }
51616   }
51617
51618   jresult = (void *)result;
51619   return jresult;
51620 }
51621
51622
51623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51624   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51625   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51626
51627   arg1 = (Dali::Vector< int > *)jarg1;
51628   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51629   {
51630     try {
51631       (arg1)->Remove(arg2);
51632     } catch (std::out_of_range& e) {
51633       {
51634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51635       };
51636     } catch (std::exception& e) {
51637       {
51638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51639       };
51640     } catch (Dali::DaliException e) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51643       };
51644     } catch (...) {
51645       {
51646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51647       };
51648     }
51649   }
51650
51651 }
51652
51653
51654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51655   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51656   Dali::Vector< int > *arg2 = 0 ;
51657
51658   arg1 = (Dali::Vector< int > *)jarg1;
51659   arg2 = (Dali::Vector< int > *)jarg2;
51660   if (!arg2) {
51661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51662     return ;
51663   }
51664   {
51665     try {
51666       (arg1)->Swap(*arg2);
51667     } catch (std::out_of_range& e) {
51668       {
51669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51670       };
51671     } catch (std::exception& e) {
51672       {
51673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51674       };
51675     } catch (Dali::DaliException e) {
51676       {
51677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51678       };
51679     } catch (...) {
51680       {
51681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51682       };
51683     }
51684   }
51685
51686 }
51687
51688
51689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51690   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51691
51692   arg1 = (Dali::Vector< int > *)jarg1;
51693   {
51694     try {
51695       (arg1)->Clear();
51696     } catch (std::out_of_range& e) {
51697       {
51698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51699       };
51700     } catch (std::exception& e) {
51701       {
51702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51703       };
51704     } catch (Dali::DaliException e) {
51705       {
51706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51707       };
51708     } catch (...) {
51709       {
51710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51711       };
51712     }
51713   }
51714
51715 }
51716
51717
51718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51719   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51720
51721   arg1 = (Dali::Vector< int > *)jarg1;
51722   {
51723     try {
51724       (arg1)->Release();
51725     } catch (std::out_of_range& e) {
51726       {
51727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51728       };
51729     } catch (std::exception& e) {
51730       {
51731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51732       };
51733     } catch (Dali::DaliException e) {
51734       {
51735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51736       };
51737     } catch (...) {
51738       {
51739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51740       };
51741     }
51742   }
51743
51744 }
51745
51746
51747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51748   int jresult ;
51749   int result;
51750
51751   result = (int)Dali::Vector< float >::BaseType;
51752   jresult = (int)result;
51753   return jresult;
51754 }
51755
51756
51757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51758   void * jresult ;
51759   Dali::Vector< float > *result = 0 ;
51760
51761   {
51762     try {
51763       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51764     } catch (std::out_of_range& e) {
51765       {
51766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51767       };
51768     } catch (std::exception& e) {
51769       {
51770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51771       };
51772     } catch (Dali::DaliException e) {
51773       {
51774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51775       };
51776     } catch (...) {
51777       {
51778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51779       };
51780     }
51781   }
51782
51783   jresult = (void *)result;
51784   return jresult;
51785 }
51786
51787
51788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51789   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51790
51791   arg1 = (Dali::Vector< float > *)jarg1;
51792   {
51793     try {
51794       delete arg1;
51795     } catch (std::out_of_range& e) {
51796       {
51797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51798       };
51799     } catch (std::exception& e) {
51800       {
51801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51802       };
51803     } catch (Dali::DaliException e) {
51804       {
51805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51806       };
51807     } catch (...) {
51808       {
51809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51810       };
51811     }
51812   }
51813
51814 }
51815
51816
51817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51818   void * jresult ;
51819   Dali::Vector< float > *arg1 = 0 ;
51820   Dali::Vector< float > *result = 0 ;
51821
51822   arg1 = (Dali::Vector< float > *)jarg1;
51823   if (!arg1) {
51824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51825     return 0;
51826   }
51827   {
51828     try {
51829       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51830     } catch (std::out_of_range& e) {
51831       {
51832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51833       };
51834     } catch (std::exception& e) {
51835       {
51836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51837       };
51838     } catch (Dali::DaliException e) {
51839       {
51840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51841       };
51842     } catch (...) {
51843       {
51844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51845       };
51846     }
51847   }
51848
51849   jresult = (void *)result;
51850   return jresult;
51851 }
51852
51853
51854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51855   void * jresult ;
51856   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51857   Dali::Vector< float > *arg2 = 0 ;
51858   Dali::Vector< float > *result = 0 ;
51859
51860   arg1 = (Dali::Vector< float > *)jarg1;
51861   arg2 = (Dali::Vector< float > *)jarg2;
51862   if (!arg2) {
51863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51864     return 0;
51865   }
51866   {
51867     try {
51868       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51869     } catch (std::out_of_range& e) {
51870       {
51871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51872       };
51873     } catch (std::exception& e) {
51874       {
51875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51876       };
51877     } catch (Dali::DaliException e) {
51878       {
51879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51880       };
51881     } catch (...) {
51882       {
51883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51884       };
51885     }
51886   }
51887
51888   jresult = (void *)result;
51889   return jresult;
51890 }
51891
51892
51893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51894   void * jresult ;
51895   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51896   Dali::Vector< float >::Iterator result;
51897
51898   arg1 = (Dali::Vector< float > *)jarg1;
51899   {
51900     try {
51901       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51902     } catch (std::out_of_range& e) {
51903       {
51904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51905       };
51906     } catch (std::exception& e) {
51907       {
51908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51909       };
51910     } catch (Dali::DaliException e) {
51911       {
51912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51913       };
51914     } catch (...) {
51915       {
51916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51917       };
51918     }
51919   }
51920
51921   jresult = (void *)result;
51922   return jresult;
51923 }
51924
51925
51926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51927   void * jresult ;
51928   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51929   Dali::Vector< float >::Iterator result;
51930
51931   arg1 = (Dali::Vector< float > *)jarg1;
51932   {
51933     try {
51934       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51935     } catch (std::out_of_range& e) {
51936       {
51937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51938       };
51939     } catch (std::exception& e) {
51940       {
51941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51942       };
51943     } catch (Dali::DaliException e) {
51944       {
51945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51946       };
51947     } catch (...) {
51948       {
51949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51950       };
51951     }
51952   }
51953
51954   jresult = (void *)result;
51955   return jresult;
51956 }
51957
51958
51959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51960   void * jresult ;
51961   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51962   Dali::Vector< float >::SizeType arg2 ;
51963   Dali::Vector< float >::ItemType *result = 0 ;
51964
51965   arg1 = (Dali::Vector< float > *)jarg1;
51966   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51967   {
51968     try {
51969       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51970     } catch (std::out_of_range& e) {
51971       {
51972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51973       };
51974     } catch (std::exception& e) {
51975       {
51976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51977       };
51978     } catch (Dali::DaliException e) {
51979       {
51980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51981       };
51982     } catch (...) {
51983       {
51984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51985       };
51986     }
51987   }
51988
51989   jresult = (void *)result;
51990   return jresult;
51991 }
51992
51993
51994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51995   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51996   Dali::Vector< float >::ItemType *arg2 = 0 ;
51997   Dali::Vector< float >::ItemType temp2 ;
51998
51999   arg1 = (Dali::Vector< float > *)jarg1;
52000   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52001   arg2 = &temp2;
52002   {
52003     try {
52004       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52005     } catch (std::out_of_range& e) {
52006       {
52007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52008       };
52009     } catch (std::exception& e) {
52010       {
52011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52012       };
52013     } catch (Dali::DaliException e) {
52014       {
52015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52016       };
52017     } catch (...) {
52018       {
52019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52020       };
52021     }
52022   }
52023
52024 }
52025
52026
52027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52028   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52029   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52030   Dali::Vector< float >::ItemType *arg3 = 0 ;
52031   Dali::Vector< float >::ItemType temp3 ;
52032
52033   arg1 = (Dali::Vector< float > *)jarg1;
52034   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52035   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52036   arg3 = &temp3;
52037   {
52038     try {
52039       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52040     } catch (std::out_of_range& e) {
52041       {
52042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52043       };
52044     } catch (std::exception& e) {
52045       {
52046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52047       };
52048     } catch (Dali::DaliException e) {
52049       {
52050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52051       };
52052     } catch (...) {
52053       {
52054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52055       };
52056     }
52057   }
52058
52059 }
52060
52061
52062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52063   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52064   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52065   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52066   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52067
52068   arg1 = (Dali::Vector< float > *)jarg1;
52069   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52070   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52071   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52072   {
52073     try {
52074       (arg1)->Insert(arg2,arg3,arg4);
52075     } catch (std::out_of_range& e) {
52076       {
52077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52078       };
52079     } catch (std::exception& e) {
52080       {
52081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52082       };
52083     } catch (Dali::DaliException e) {
52084       {
52085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52086       };
52087     } catch (...) {
52088       {
52089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52090       };
52091     }
52092   }
52093
52094 }
52095
52096
52097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52098   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52099   Dali::Vector< float >::SizeType arg2 ;
52100
52101   arg1 = (Dali::Vector< float > *)jarg1;
52102   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52103   {
52104     try {
52105       (arg1)->Reserve(arg2);
52106     } catch (std::out_of_range& e) {
52107       {
52108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52109       };
52110     } catch (std::exception& e) {
52111       {
52112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52113       };
52114     } catch (Dali::DaliException e) {
52115       {
52116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52117       };
52118     } catch (...) {
52119       {
52120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52121       };
52122     }
52123   }
52124
52125 }
52126
52127 //// ========================= end of part 2 =============================
52128
52129 //// ========================== start part 3 ===============================
52130
52131
52132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52133   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52134   Dali::Vector< float >::SizeType arg2 ;
52135
52136   arg1 = (Dali::Vector< float > *)jarg1;
52137   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52138   {
52139     try {
52140       (arg1)->Resize(arg2);
52141     } catch (std::out_of_range& e) {
52142       {
52143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52144       };
52145     } catch (std::exception& e) {
52146       {
52147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52148       };
52149     } catch (Dali::DaliException e) {
52150       {
52151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52152       };
52153     } catch (...) {
52154       {
52155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52156       };
52157     }
52158   }
52159
52160 }
52161
52162
52163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52164   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52165   Dali::Vector< float >::SizeType arg2 ;
52166   Dali::Vector< float >::ItemType *arg3 = 0 ;
52167   Dali::Vector< float >::ItemType temp3 ;
52168
52169   arg1 = (Dali::Vector< float > *)jarg1;
52170   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52171   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52172   arg3 = &temp3;
52173   {
52174     try {
52175       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52176     } catch (std::out_of_range& e) {
52177       {
52178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52179       };
52180     } catch (std::exception& e) {
52181       {
52182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52183       };
52184     } catch (Dali::DaliException e) {
52185       {
52186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52187       };
52188     } catch (...) {
52189       {
52190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52191       };
52192     }
52193   }
52194
52195 }
52196
52197
52198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52199   void * jresult ;
52200   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52201   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52202   Dali::Vector< float >::Iterator result;
52203
52204   arg1 = (Dali::Vector< float > *)jarg1;
52205   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52206   {
52207     try {
52208       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52209     } catch (std::out_of_range& e) {
52210       {
52211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52212       };
52213     } catch (std::exception& e) {
52214       {
52215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52216       };
52217     } catch (Dali::DaliException e) {
52218       {
52219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52220       };
52221     } catch (...) {
52222       {
52223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52224       };
52225     }
52226   }
52227
52228   jresult = (void *)result;
52229   return jresult;
52230 }
52231
52232
52233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52234   void * jresult ;
52235   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52236   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52237   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52238   Dali::Vector< float >::Iterator result;
52239
52240   arg1 = (Dali::Vector< float > *)jarg1;
52241   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52242   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52243   {
52244     try {
52245       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52246     } catch (std::out_of_range& e) {
52247       {
52248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52249       };
52250     } catch (std::exception& e) {
52251       {
52252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52253       };
52254     } catch (Dali::DaliException e) {
52255       {
52256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52257       };
52258     } catch (...) {
52259       {
52260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52261       };
52262     }
52263   }
52264
52265   jresult = (void *)result;
52266   return jresult;
52267 }
52268
52269
52270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52271   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52272   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52273
52274   arg1 = (Dali::Vector< float > *)jarg1;
52275   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52276   {
52277     try {
52278       (arg1)->Remove(arg2);
52279     } catch (std::out_of_range& e) {
52280       {
52281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52282       };
52283     } catch (std::exception& e) {
52284       {
52285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52286       };
52287     } catch (Dali::DaliException e) {
52288       {
52289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52290       };
52291     } catch (...) {
52292       {
52293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52294       };
52295     }
52296   }
52297
52298 }
52299
52300
52301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52302   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52303   Dali::Vector< float > *arg2 = 0 ;
52304
52305   arg1 = (Dali::Vector< float > *)jarg1;
52306   arg2 = (Dali::Vector< float > *)jarg2;
52307   if (!arg2) {
52308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52309     return ;
52310   }
52311   {
52312     try {
52313       (arg1)->Swap(*arg2);
52314     } catch (std::out_of_range& e) {
52315       {
52316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52317       };
52318     } catch (std::exception& e) {
52319       {
52320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52321       };
52322     } catch (Dali::DaliException e) {
52323       {
52324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52325       };
52326     } catch (...) {
52327       {
52328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52329       };
52330     }
52331   }
52332
52333 }
52334
52335
52336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52337   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52338
52339   arg1 = (Dali::Vector< float > *)jarg1;
52340   {
52341     try {
52342       (arg1)->Clear();
52343     } catch (std::out_of_range& e) {
52344       {
52345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52346       };
52347     } catch (std::exception& e) {
52348       {
52349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52350       };
52351     } catch (Dali::DaliException e) {
52352       {
52353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52354       };
52355     } catch (...) {
52356       {
52357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52358       };
52359     }
52360   }
52361
52362 }
52363
52364
52365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52366   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52367
52368   arg1 = (Dali::Vector< float > *)jarg1;
52369   {
52370     try {
52371       (arg1)->Release();
52372     } catch (std::out_of_range& e) {
52373       {
52374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52375       };
52376     } catch (std::exception& e) {
52377       {
52378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52379       };
52380     } catch (Dali::DaliException e) {
52381       {
52382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52383       };
52384     } catch (...) {
52385       {
52386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52387       };
52388     }
52389   }
52390
52391 }
52392
52393
52394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52395   int jresult ;
52396   int result;
52397
52398   result = (int)Dali::Vector< unsigned char >::BaseType;
52399   jresult = (int)result;
52400   return jresult;
52401 }
52402
52403
52404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52405   void * jresult ;
52406   Dali::Vector< unsigned char > *result = 0 ;
52407
52408   {
52409     try {
52410       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52411     } catch (std::out_of_range& e) {
52412       {
52413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52414       };
52415     } catch (std::exception& e) {
52416       {
52417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52418       };
52419     } catch (Dali::DaliException e) {
52420       {
52421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52422       };
52423     } catch (...) {
52424       {
52425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52426       };
52427     }
52428   }
52429
52430   jresult = (void *)result;
52431   return jresult;
52432 }
52433
52434
52435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52436   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52437
52438   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52439   {
52440     try {
52441       delete arg1;
52442     } catch (std::out_of_range& e) {
52443       {
52444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52445       };
52446     } catch (std::exception& e) {
52447       {
52448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52449       };
52450     } catch (Dali::DaliException e) {
52451       {
52452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52453       };
52454     } catch (...) {
52455       {
52456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52457       };
52458     }
52459   }
52460
52461 }
52462
52463
52464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52465   void * jresult ;
52466   Dali::Vector< unsigned char > *arg1 = 0 ;
52467   Dali::Vector< unsigned char > *result = 0 ;
52468
52469   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52470   if (!arg1) {
52471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52472     return 0;
52473   }
52474   {
52475     try {
52476       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52477     } catch (std::out_of_range& e) {
52478       {
52479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52480       };
52481     } catch (std::exception& e) {
52482       {
52483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52484       };
52485     } catch (Dali::DaliException e) {
52486       {
52487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52488       };
52489     } catch (...) {
52490       {
52491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52492       };
52493     }
52494   }
52495
52496   jresult = (void *)result;
52497   return jresult;
52498 }
52499
52500
52501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52502   void * jresult ;
52503   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52504   Dali::Vector< unsigned char > *arg2 = 0 ;
52505   Dali::Vector< unsigned char > *result = 0 ;
52506
52507   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52508   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52509   if (!arg2) {
52510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52511     return 0;
52512   }
52513   {
52514     try {
52515       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52516     } catch (std::out_of_range& e) {
52517       {
52518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52519       };
52520     } catch (std::exception& e) {
52521       {
52522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52523       };
52524     } catch (Dali::DaliException e) {
52525       {
52526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52527       };
52528     } catch (...) {
52529       {
52530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52531       };
52532     }
52533   }
52534
52535   jresult = (void *)result;
52536   return jresult;
52537 }
52538
52539
52540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52541   void * jresult ;
52542   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52543   Dali::Vector< unsigned char >::Iterator result;
52544
52545   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52546   {
52547     try {
52548       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52549     } catch (std::out_of_range& e) {
52550       {
52551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52552       };
52553     } catch (std::exception& e) {
52554       {
52555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52556       };
52557     } catch (Dali::DaliException e) {
52558       {
52559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52560       };
52561     } catch (...) {
52562       {
52563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52564       };
52565     }
52566   }
52567
52568   jresult = (void *)result;
52569   return jresult;
52570 }
52571
52572
52573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52574   void * jresult ;
52575   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52576   Dali::Vector< unsigned char >::Iterator result;
52577
52578   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52579   {
52580     try {
52581       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52582     } catch (std::out_of_range& e) {
52583       {
52584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52585       };
52586     } catch (std::exception& e) {
52587       {
52588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52589       };
52590     } catch (Dali::DaliException e) {
52591       {
52592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52593       };
52594     } catch (...) {
52595       {
52596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52597       };
52598     }
52599   }
52600
52601   jresult = (void *)result;
52602   return jresult;
52603 }
52604
52605
52606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52607   void * jresult ;
52608   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52609   Dali::Vector< unsigned char >::SizeType arg2 ;
52610   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52611
52612   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52613   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52614   {
52615     try {
52616       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52617     } catch (std::out_of_range& e) {
52618       {
52619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52620       };
52621     } catch (std::exception& e) {
52622       {
52623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52624       };
52625     } catch (Dali::DaliException e) {
52626       {
52627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52628       };
52629     } catch (...) {
52630       {
52631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52632       };
52633     }
52634   }
52635
52636   jresult = (void *)result;
52637   return jresult;
52638 }
52639
52640
52641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52642   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52643   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52644   Dali::Vector< unsigned char >::ItemType temp2 ;
52645
52646   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52647   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52648   arg2 = &temp2;
52649   {
52650     try {
52651       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52652     } catch (std::out_of_range& e) {
52653       {
52654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52655       };
52656     } catch (std::exception& e) {
52657       {
52658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52659       };
52660     } catch (Dali::DaliException e) {
52661       {
52662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52663       };
52664     } catch (...) {
52665       {
52666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52667       };
52668     }
52669   }
52670
52671 }
52672
52673
52674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52675   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52676   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52677   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52678   Dali::Vector< unsigned char >::ItemType temp3 ;
52679
52680   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52681   arg2 = jarg2;
52682   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52683   arg3 = &temp3;
52684   {
52685     try {
52686       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52687     } catch (std::out_of_range& e) {
52688       {
52689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52690       };
52691     } catch (std::exception& e) {
52692       {
52693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52694       };
52695     } catch (Dali::DaliException e) {
52696       {
52697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52698       };
52699     } catch (...) {
52700       {
52701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52702       };
52703     }
52704   }
52705
52706
52707
52708 }
52709
52710
52711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52712   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52713   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52714   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52715   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52716
52717   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52718   arg2 = jarg2;
52719   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52720   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52721   {
52722     try {
52723       (arg1)->Insert(arg2,arg3,arg4);
52724     } catch (std::out_of_range& e) {
52725       {
52726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52727       };
52728     } catch (std::exception& e) {
52729       {
52730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52731       };
52732     } catch (Dali::DaliException e) {
52733       {
52734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52735       };
52736     } catch (...) {
52737       {
52738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52739       };
52740     }
52741   }
52742
52743
52744
52745 }
52746
52747
52748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52749   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52750   Dali::Vector< unsigned char >::SizeType arg2 ;
52751
52752   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52753   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52754   {
52755     try {
52756       (arg1)->Reserve(arg2);
52757     } catch (std::out_of_range& e) {
52758       {
52759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52760       };
52761     } catch (std::exception& e) {
52762       {
52763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52764       };
52765     } catch (Dali::DaliException e) {
52766       {
52767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52768       };
52769     } catch (...) {
52770       {
52771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52772       };
52773     }
52774   }
52775
52776 }
52777
52778
52779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52780   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52781   Dali::Vector< unsigned char >::SizeType arg2 ;
52782
52783   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52784   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52785   {
52786     try {
52787       (arg1)->Resize(arg2);
52788     } catch (std::out_of_range& e) {
52789       {
52790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52791       };
52792     } catch (std::exception& e) {
52793       {
52794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52795       };
52796     } catch (Dali::DaliException e) {
52797       {
52798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52799       };
52800     } catch (...) {
52801       {
52802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52803       };
52804     }
52805   }
52806
52807 }
52808
52809
52810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52811   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52812   Dali::Vector< unsigned char >::SizeType arg2 ;
52813   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52814   Dali::Vector< unsigned char >::ItemType temp3 ;
52815
52816   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52817   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52818   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52819   arg3 = &temp3;
52820   {
52821     try {
52822       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52823     } catch (std::out_of_range& e) {
52824       {
52825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52826       };
52827     } catch (std::exception& e) {
52828       {
52829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52830       };
52831     } catch (Dali::DaliException e) {
52832       {
52833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52834       };
52835     } catch (...) {
52836       {
52837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52838       };
52839     }
52840   }
52841
52842 }
52843
52844
52845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52846   void * jresult ;
52847   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52848   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52849   Dali::Vector< unsigned char >::Iterator result;
52850
52851   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52852   arg2 = jarg2;
52853   {
52854     try {
52855       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52856     } catch (std::out_of_range& e) {
52857       {
52858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52859       };
52860     } catch (std::exception& e) {
52861       {
52862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52863       };
52864     } catch (Dali::DaliException e) {
52865       {
52866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52867       };
52868     } catch (...) {
52869       {
52870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52871       };
52872     }
52873   }
52874
52875   jresult = (void *)result;
52876
52877
52878   return jresult;
52879 }
52880
52881
52882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52883   void * jresult ;
52884   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52885   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52886   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52887   Dali::Vector< unsigned char >::Iterator result;
52888
52889   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52890   arg2 = jarg2;
52891   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52892   {
52893     try {
52894       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52895     } catch (std::out_of_range& e) {
52896       {
52897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52898       };
52899     } catch (std::exception& e) {
52900       {
52901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52902       };
52903     } catch (Dali::DaliException e) {
52904       {
52905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52906       };
52907     } catch (...) {
52908       {
52909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52910       };
52911     }
52912   }
52913
52914   jresult = (void *)result;
52915
52916
52917   return jresult;
52918 }
52919
52920
52921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52922   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52923   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52924
52925   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52926   arg2 = jarg2;
52927   {
52928     try {
52929       (arg1)->Remove(arg2);
52930     } catch (std::out_of_range& e) {
52931       {
52932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52933       };
52934     } catch (std::exception& e) {
52935       {
52936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52937       };
52938     } catch (Dali::DaliException e) {
52939       {
52940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52941       };
52942     } catch (...) {
52943       {
52944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52945       };
52946     }
52947   }
52948
52949
52950
52951 }
52952
52953
52954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52955   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52956   Dali::Vector< unsigned char > *arg2 = 0 ;
52957
52958   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52959   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52960   if (!arg2) {
52961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52962     return ;
52963   }
52964   {
52965     try {
52966       (arg1)->Swap(*arg2);
52967     } catch (std::out_of_range& e) {
52968       {
52969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52970       };
52971     } catch (std::exception& e) {
52972       {
52973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52974       };
52975     } catch (Dali::DaliException e) {
52976       {
52977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52978       };
52979     } catch (...) {
52980       {
52981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52982       };
52983     }
52984   }
52985
52986 }
52987
52988
52989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52990   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52991
52992   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52993   {
52994     try {
52995       (arg1)->Clear();
52996     } catch (std::out_of_range& e) {
52997       {
52998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52999       };
53000     } catch (std::exception& e) {
53001       {
53002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53003       };
53004     } catch (Dali::DaliException e) {
53005       {
53006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53007       };
53008     } catch (...) {
53009       {
53010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53011       };
53012     }
53013   }
53014
53015 }
53016
53017
53018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53019   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53020
53021   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53022   {
53023     try {
53024       (arg1)->Release();
53025     } catch (std::out_of_range& e) {
53026       {
53027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53028       };
53029     } catch (std::exception& e) {
53030       {
53031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53032       };
53033     } catch (Dali::DaliException e) {
53034       {
53035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53036       };
53037     } catch (...) {
53038       {
53039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53040       };
53041     }
53042   }
53043
53044 }
53045
53046
53047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53048   int jresult ;
53049   int result;
53050
53051   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53052   jresult = (int)result;
53053   return jresult;
53054 }
53055
53056
53057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53058   void * jresult ;
53059   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53060
53061   {
53062     try {
53063       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53064     } catch (std::out_of_range& e) {
53065       {
53066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53067       };
53068     } catch (std::exception& e) {
53069       {
53070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53071       };
53072     } catch (Dali::DaliException e) {
53073       {
53074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53075       };
53076     } catch (...) {
53077       {
53078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53079       };
53080     }
53081   }
53082
53083   jresult = (void *)result;
53084   return jresult;
53085 }
53086
53087
53088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53089   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53090
53091   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53092   {
53093     try {
53094       delete arg1;
53095     } catch (std::out_of_range& e) {
53096       {
53097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53098       };
53099     } catch (std::exception& e) {
53100       {
53101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53102       };
53103     } catch (Dali::DaliException e) {
53104       {
53105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53106       };
53107     } catch (...) {
53108       {
53109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53110       };
53111     }
53112   }
53113
53114 }
53115
53116
53117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53118   void * jresult ;
53119   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53120   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53121
53122   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53123   if (!arg1) {
53124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53125     return 0;
53126   }
53127   {
53128     try {
53129       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53130     } catch (std::out_of_range& e) {
53131       {
53132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53133       };
53134     } catch (std::exception& e) {
53135       {
53136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53137       };
53138     } catch (Dali::DaliException e) {
53139       {
53140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53141       };
53142     } catch (...) {
53143       {
53144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53145       };
53146     }
53147   }
53148
53149   jresult = (void *)result;
53150   return jresult;
53151 }
53152
53153
53154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53155   void * jresult ;
53156   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53157   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53158   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53159
53160   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53161   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53162   if (!arg2) {
53163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53164     return 0;
53165   }
53166   {
53167     try {
53168       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53169     } catch (std::out_of_range& e) {
53170       {
53171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53172       };
53173     } catch (std::exception& e) {
53174       {
53175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53176       };
53177     } catch (Dali::DaliException e) {
53178       {
53179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53180       };
53181     } catch (...) {
53182       {
53183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53184       };
53185     }
53186   }
53187
53188   jresult = (void *)result;
53189   return jresult;
53190 }
53191
53192
53193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53194   void * jresult ;
53195   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53196   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53197
53198   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53199   {
53200     try {
53201       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53202     } catch (std::out_of_range& e) {
53203       {
53204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53205       };
53206     } catch (std::exception& e) {
53207       {
53208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53209       };
53210     } catch (Dali::DaliException e) {
53211       {
53212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53213       };
53214     } catch (...) {
53215       {
53216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53217       };
53218     }
53219   }
53220
53221   jresult = (void *)result;
53222   return jresult;
53223 }
53224
53225
53226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53227   void * jresult ;
53228   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53229   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53230
53231   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53232   {
53233     try {
53234       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53242       };
53243     } catch (Dali::DaliException e) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53246       };
53247     } catch (...) {
53248       {
53249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53250       };
53251     }
53252   }
53253
53254   jresult = (void *)result;
53255   return jresult;
53256 }
53257
53258
53259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53260   void * jresult ;
53261   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53262   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53263   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53264
53265   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53266   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53267   {
53268     try {
53269       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53270     } catch (std::out_of_range& e) {
53271       {
53272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53273       };
53274     } catch (std::exception& e) {
53275       {
53276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53277       };
53278     } catch (Dali::DaliException e) {
53279       {
53280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53281       };
53282     } catch (...) {
53283       {
53284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53285       };
53286     }
53287   }
53288
53289   jresult = (void *)result;
53290   return jresult;
53291 }
53292
53293
53294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53295   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53296   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53297
53298   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53299   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53300   if (!arg2) {
53301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53302     return ;
53303   }
53304   {
53305     try {
53306       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53307     } catch (std::out_of_range& e) {
53308       {
53309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53310       };
53311     } catch (std::exception& e) {
53312       {
53313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53314       };
53315     } catch (Dali::DaliException e) {
53316       {
53317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53318       };
53319     } catch (...) {
53320       {
53321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53322       };
53323     }
53324   }
53325
53326 }
53327
53328
53329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53330   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53331   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53332   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53333
53334   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53335   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53336   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53337   if (!arg3) {
53338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53339     return ;
53340   }
53341   {
53342     try {
53343       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53344     } catch (std::out_of_range& e) {
53345       {
53346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53347       };
53348     } catch (std::exception& e) {
53349       {
53350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53351       };
53352     } catch (Dali::DaliException e) {
53353       {
53354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53355       };
53356     } catch (...) {
53357       {
53358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53359       };
53360     }
53361   }
53362
53363 }
53364
53365
53366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53367   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53368   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53369   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53370   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53371
53372   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53373   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53374   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53375   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53376   {
53377     try {
53378       (arg1)->Insert(arg2,arg3,arg4);
53379     } catch (std::out_of_range& e) {
53380       {
53381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53382       };
53383     } catch (std::exception& e) {
53384       {
53385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53386       };
53387     } catch (Dali::DaliException e) {
53388       {
53389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53390       };
53391     } catch (...) {
53392       {
53393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53394       };
53395     }
53396   }
53397
53398 }
53399
53400
53401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53402   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53403   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53404
53405   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53406   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53407   {
53408     try {
53409       (arg1)->Reserve(arg2);
53410     } catch (std::out_of_range& e) {
53411       {
53412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53413       };
53414     } catch (std::exception& e) {
53415       {
53416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53417       };
53418     } catch (Dali::DaliException e) {
53419       {
53420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53421       };
53422     } catch (...) {
53423       {
53424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53425       };
53426     }
53427   }
53428
53429 }
53430
53431
53432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53433   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53434   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53435
53436   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53437   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53438   {
53439     try {
53440       (arg1)->Resize(arg2);
53441     } catch (std::out_of_range& e) {
53442       {
53443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53444       };
53445     } catch (std::exception& e) {
53446       {
53447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53448       };
53449     } catch (Dali::DaliException e) {
53450       {
53451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53452       };
53453     } catch (...) {
53454       {
53455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53456       };
53457     }
53458   }
53459
53460 }
53461
53462
53463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53464   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53465   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53466   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53467
53468   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53469   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53470   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53471   if (!arg3) {
53472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53473     return ;
53474   }
53475   {
53476     try {
53477       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53478     } catch (std::out_of_range& e) {
53479       {
53480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53481       };
53482     } catch (std::exception& e) {
53483       {
53484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53485       };
53486     } catch (Dali::DaliException e) {
53487       {
53488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53489       };
53490     } catch (...) {
53491       {
53492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53493       };
53494     }
53495   }
53496
53497 }
53498
53499
53500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53501   void * jresult ;
53502   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53503   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53504   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53505
53506   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53507   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53508   {
53509     try {
53510       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53511     } catch (std::out_of_range& e) {
53512       {
53513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53514       };
53515     } catch (std::exception& e) {
53516       {
53517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53518       };
53519     } catch (Dali::DaliException e) {
53520       {
53521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53522       };
53523     } catch (...) {
53524       {
53525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53526       };
53527     }
53528   }
53529
53530   jresult = (void *)result;
53531   return jresult;
53532 }
53533
53534
53535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53536   void * jresult ;
53537   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53538   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53539   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53540   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53541
53542   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53543   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53544   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53545   {
53546     try {
53547       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53548     } catch (std::out_of_range& e) {
53549       {
53550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53551       };
53552     } catch (std::exception& e) {
53553       {
53554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53555       };
53556     } catch (Dali::DaliException e) {
53557       {
53558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53559       };
53560     } catch (...) {
53561       {
53562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53563       };
53564     }
53565   }
53566
53567   jresult = (void *)result;
53568   return jresult;
53569 }
53570
53571
53572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53573   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53574   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53575
53576   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53577   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53578   {
53579     try {
53580       (arg1)->Remove(arg2);
53581     } catch (std::out_of_range& e) {
53582       {
53583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53584       };
53585     } catch (std::exception& e) {
53586       {
53587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53588       };
53589     } catch (Dali::DaliException e) {
53590       {
53591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53592       };
53593     } catch (...) {
53594       {
53595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53596       };
53597     }
53598   }
53599
53600 }
53601
53602
53603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53604   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53605   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53606
53607   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53608   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53609   if (!arg2) {
53610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53611     return ;
53612   }
53613   {
53614     try {
53615       (arg1)->Swap(*arg2);
53616     } catch (std::out_of_range& e) {
53617       {
53618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53619       };
53620     } catch (std::exception& e) {
53621       {
53622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53623       };
53624     } catch (Dali::DaliException e) {
53625       {
53626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53627       };
53628     } catch (...) {
53629       {
53630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53631       };
53632     }
53633   }
53634
53635 }
53636
53637
53638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53639   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53640
53641   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53642   {
53643     try {
53644       (arg1)->Clear();
53645     } catch (std::out_of_range& e) {
53646       {
53647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53648       };
53649     } catch (std::exception& e) {
53650       {
53651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53652       };
53653     } catch (Dali::DaliException e) {
53654       {
53655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53656       };
53657     } catch (...) {
53658       {
53659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53660       };
53661     }
53662   }
53663
53664 }
53665
53666
53667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53668   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53669
53670   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53671   {
53672     try {
53673       (arg1)->Release();
53674     } catch (std::out_of_range& e) {
53675       {
53676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53677       };
53678     } catch (std::exception& e) {
53679       {
53680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53681       };
53682     } catch (Dali::DaliException e) {
53683       {
53684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53685       };
53686     } catch (...) {
53687       {
53688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53689       };
53690     }
53691   }
53692
53693 }
53694
53695
53696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53697   void * jresult ;
53698   Dali::Signal< void () > *result = 0 ;
53699
53700   {
53701     try {
53702       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53703     } catch (std::out_of_range& e) {
53704       {
53705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53706       };
53707     } catch (std::exception& e) {
53708       {
53709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53710       };
53711     } catch (Dali::DaliException e) {
53712       {
53713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53714       };
53715     } catch (...) {
53716       {
53717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53718       };
53719     }
53720   }
53721
53722   jresult = (void *)result;
53723   return jresult;
53724 }
53725
53726
53727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53728   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53729
53730   arg1 = (Dali::Signal< void () > *)jarg1;
53731   {
53732     try {
53733       delete arg1;
53734     } catch (std::out_of_range& e) {
53735       {
53736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53737       };
53738     } catch (std::exception& e) {
53739       {
53740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53741       };
53742     } catch (Dali::DaliException e) {
53743       {
53744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53745       };
53746     } catch (...) {
53747       {
53748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53749       };
53750     }
53751   }
53752
53753 }
53754
53755
53756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53757   unsigned int jresult ;
53758   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53759   bool result;
53760
53761   arg1 = (Dali::Signal< void () > *)jarg1;
53762   {
53763     try {
53764       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53765     } catch (std::out_of_range& e) {
53766       {
53767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53768       };
53769     } catch (std::exception& e) {
53770       {
53771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53772       };
53773     } catch (Dali::DaliException e) {
53774       {
53775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53776       };
53777     } catch (...) {
53778       {
53779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53780       };
53781     }
53782   }
53783
53784   jresult = result;
53785   return jresult;
53786 }
53787
53788
53789 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53790   unsigned long jresult ;
53791   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53792   std::size_t result;
53793
53794   arg1 = (Dali::Signal< void () > *)jarg1;
53795   {
53796     try {
53797       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53798     } catch (std::out_of_range& e) {
53799       {
53800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53801       };
53802     } catch (std::exception& e) {
53803       {
53804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53805       };
53806     } catch (Dali::DaliException e) {
53807       {
53808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53809       };
53810     } catch (...) {
53811       {
53812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53813       };
53814     }
53815   }
53816
53817   jresult = (unsigned long)result;
53818   return jresult;
53819 }
53820
53821
53822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53823   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53824   void (*arg2)() = (void (*)()) 0 ;
53825
53826   arg1 = (Dali::Signal< void () > *)jarg1;
53827   arg2 = (void (*)())jarg2;
53828   {
53829     try {
53830       (arg1)->Connect(arg2);
53831     } catch (std::out_of_range& e) {
53832       {
53833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53834       };
53835     } catch (std::exception& e) {
53836       {
53837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53838       };
53839     } catch (Dali::DaliException e) {
53840       {
53841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53842       };
53843     } catch (...) {
53844       {
53845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53846       };
53847     }
53848   }
53849
53850 }
53851
53852
53853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53854   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53855   void (*arg2)() = (void (*)()) 0 ;
53856
53857   arg1 = (Dali::Signal< void () > *)jarg1;
53858   arg2 = (void (*)())jarg2;
53859   {
53860     try {
53861       (arg1)->Disconnect(arg2);
53862     } catch (std::out_of_range& e) {
53863       {
53864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53865       };
53866     } catch (std::exception& e) {
53867       {
53868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53869       };
53870     } catch (Dali::DaliException e) {
53871       {
53872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53873       };
53874     } catch (...) {
53875       {
53876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53877       };
53878     }
53879   }
53880
53881 }
53882
53883
53884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53885   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53886   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53887   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53888
53889   arg1 = (Dali::Signal< void () > *)jarg1;
53890   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53891   arg3 = (Dali::FunctorDelegate *)jarg3;
53892   {
53893     try {
53894       (arg1)->Connect(arg2,arg3);
53895     } catch (std::out_of_range& e) {
53896       {
53897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53898       };
53899     } catch (std::exception& e) {
53900       {
53901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53902       };
53903     } catch (Dali::DaliException e) {
53904       {
53905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53906       };
53907     } catch (...) {
53908       {
53909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53910       };
53911     }
53912   }
53913
53914 }
53915
53916
53917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53918   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53919
53920   arg1 = (Dali::Signal< void () > *)jarg1;
53921   {
53922     try {
53923       (arg1)->Emit();
53924     } catch (std::out_of_range& e) {
53925       {
53926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53927       };
53928     } catch (std::exception& e) {
53929       {
53930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53931       };
53932     } catch (Dali::DaliException e) {
53933       {
53934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53935       };
53936     } catch (...) {
53937       {
53938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53939       };
53940     }
53941   }
53942
53943 }
53944
53945
53946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53947   unsigned int jresult ;
53948   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53949   bool result;
53950
53951   arg1 = (Dali::Signal< void (float) > *)jarg1;
53952   {
53953     try {
53954       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53955     } catch (std::out_of_range& e) {
53956       {
53957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53958       };
53959     } catch (std::exception& e) {
53960       {
53961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53962       };
53963     } catch (Dali::DaliException e) {
53964       {
53965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53966       };
53967     } catch (...) {
53968       {
53969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53970       };
53971     }
53972   }
53973
53974   jresult = result;
53975   return jresult;
53976 }
53977
53978
53979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53980   unsigned long jresult ;
53981   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53982   std::size_t result;
53983
53984   arg1 = (Dali::Signal< void (float) > *)jarg1;
53985   {
53986     try {
53987       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53988     } catch (std::out_of_range& e) {
53989       {
53990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53991       };
53992     } catch (std::exception& e) {
53993       {
53994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53995       };
53996     } catch (Dali::DaliException e) {
53997       {
53998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53999       };
54000     } catch (...) {
54001       {
54002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54003       };
54004     }
54005   }
54006
54007   jresult = (unsigned long)result;
54008   return jresult;
54009 }
54010
54011
54012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54013   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54014   void (*arg2)(float) = (void (*)(float)) 0 ;
54015
54016   arg1 = (Dali::Signal< void (float) > *)jarg1;
54017   arg2 = (void (*)(float))jarg2;
54018   {
54019     try {
54020       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54021     } catch (std::out_of_range& e) {
54022       {
54023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54024       };
54025     } catch (std::exception& e) {
54026       {
54027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54028       };
54029     } catch (Dali::DaliException e) {
54030       {
54031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54032       };
54033     } catch (...) {
54034       {
54035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54036       };
54037     }
54038   }
54039
54040 }
54041
54042
54043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54044   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54045   void (*arg2)(float) = (void (*)(float)) 0 ;
54046
54047   arg1 = (Dali::Signal< void (float) > *)jarg1;
54048   arg2 = (void (*)(float))jarg2;
54049   {
54050     try {
54051       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54052     } catch (std::out_of_range& e) {
54053       {
54054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54055       };
54056     } catch (std::exception& e) {
54057       {
54058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54059       };
54060     } catch (Dali::DaliException e) {
54061       {
54062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54063       };
54064     } catch (...) {
54065       {
54066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54067       };
54068     }
54069   }
54070
54071 }
54072
54073
54074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54075   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54076   float arg2 ;
54077
54078   arg1 = (Dali::Signal< void (float) > *)jarg1;
54079   arg2 = (float)jarg2;
54080   {
54081     try {
54082       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54083     } catch (std::out_of_range& e) {
54084       {
54085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54086       };
54087     } catch (std::exception& e) {
54088       {
54089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54090       };
54091     } catch (Dali::DaliException e) {
54092       {
54093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54094       };
54095     } catch (...) {
54096       {
54097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54098       };
54099     }
54100   }
54101
54102 }
54103
54104
54105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54106   void * jresult ;
54107   Dali::Signal< void (float) > *result = 0 ;
54108
54109   {
54110     try {
54111       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54112     } catch (std::out_of_range& e) {
54113       {
54114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54115       };
54116     } catch (std::exception& e) {
54117       {
54118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54119       };
54120     } catch (Dali::DaliException e) {
54121       {
54122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54123       };
54124     } catch (...) {
54125       {
54126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54127       };
54128     }
54129   }
54130
54131   jresult = (void *)result;
54132   return jresult;
54133 }
54134
54135
54136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54137   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54138
54139   arg1 = (Dali::Signal< void (float) > *)jarg1;
54140   {
54141     try {
54142       delete arg1;
54143     } catch (std::out_of_range& e) {
54144       {
54145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54146       };
54147     } catch (std::exception& e) {
54148       {
54149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54150       };
54151     } catch (Dali::DaliException e) {
54152       {
54153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54154       };
54155     } catch (...) {
54156       {
54157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54158       };
54159     }
54160   }
54161
54162 }
54163
54164
54165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54166   unsigned int jresult ;
54167   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54168   bool result;
54169
54170   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54171   {
54172     try {
54173       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54174     } catch (std::out_of_range& e) {
54175       {
54176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54177       };
54178     } catch (std::exception& e) {
54179       {
54180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54181       };
54182     } catch (Dali::DaliException e) {
54183       {
54184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54185       };
54186     } catch (...) {
54187       {
54188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54189       };
54190     }
54191   }
54192
54193   jresult = result;
54194   return jresult;
54195 }
54196
54197
54198 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54199   unsigned long jresult ;
54200   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54201   std::size_t result;
54202
54203   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54204   {
54205     try {
54206       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54207     } catch (std::out_of_range& e) {
54208       {
54209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54210       };
54211     } catch (std::exception& e) {
54212       {
54213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54214       };
54215     } catch (Dali::DaliException e) {
54216       {
54217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54218       };
54219     } catch (...) {
54220       {
54221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54222       };
54223     }
54224   }
54225
54226   jresult = (unsigned long)result;
54227   return jresult;
54228 }
54229
54230
54231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54232   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54233   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54234
54235   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54236   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54237   {
54238     try {
54239       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54240     } catch (std::out_of_range& e) {
54241       {
54242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54243       };
54244     } catch (std::exception& e) {
54245       {
54246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54247       };
54248     } catch (Dali::DaliException e) {
54249       {
54250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54251       };
54252     } catch (...) {
54253       {
54254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54255       };
54256     }
54257   }
54258
54259 }
54260
54261
54262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54263   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54264   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54265
54266   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54267   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54268   {
54269     try {
54270       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54271     } catch (std::out_of_range& e) {
54272       {
54273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54274       };
54275     } catch (std::exception& e) {
54276       {
54277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54278       };
54279     } catch (Dali::DaliException e) {
54280       {
54281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54282       };
54283     } catch (...) {
54284       {
54285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54286       };
54287     }
54288   }
54289
54290 }
54291
54292
54293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54294   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54295   Dali::BaseHandle arg2 ;
54296   Dali::BaseHandle *argp2 ;
54297
54298   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54299   argp2 = (Dali::BaseHandle *)jarg2;
54300   if (!argp2) {
54301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54302     return ;
54303   }
54304   arg2 = *argp2;
54305   {
54306     try {
54307       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54308     } catch (std::out_of_range& e) {
54309       {
54310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54311       };
54312     } catch (std::exception& e) {
54313       {
54314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54315       };
54316     } catch (Dali::DaliException e) {
54317       {
54318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54319       };
54320     } catch (...) {
54321       {
54322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54323       };
54324     }
54325   }
54326
54327 }
54328
54329
54330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54331   void * jresult ;
54332   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54333
54334   {
54335     try {
54336       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54337     } catch (std::out_of_range& e) {
54338       {
54339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54340       };
54341     } catch (std::exception& e) {
54342       {
54343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54344       };
54345     } catch (Dali::DaliException e) {
54346       {
54347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54348       };
54349     } catch (...) {
54350       {
54351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54352       };
54353     }
54354   }
54355
54356   jresult = (void *)result;
54357   return jresult;
54358 }
54359
54360
54361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54362   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54363
54364   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54365   {
54366     try {
54367       delete arg1;
54368     } catch (std::out_of_range& e) {
54369       {
54370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54371       };
54372     } catch (std::exception& e) {
54373       {
54374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54375       };
54376     } catch (Dali::DaliException e) {
54377       {
54378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54379       };
54380     } catch (...) {
54381       {
54382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54383       };
54384     }
54385   }
54386
54387 }
54388
54389
54390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54391   unsigned int jresult ;
54392   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54393   bool result;
54394
54395   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54396   {
54397     try {
54398       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54399     } catch (std::out_of_range& e) {
54400       {
54401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54402       };
54403     } catch (std::exception& e) {
54404       {
54405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54406       };
54407     } catch (Dali::DaliException e) {
54408       {
54409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54410       };
54411     } catch (...) {
54412       {
54413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54414       };
54415     }
54416   }
54417
54418   jresult = result;
54419   return jresult;
54420 }
54421
54422
54423 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54424   unsigned long jresult ;
54425   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54426   std::size_t result;
54427
54428   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54429   {
54430     try {
54431       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54432     } catch (std::out_of_range& e) {
54433       {
54434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54435       };
54436     } catch (std::exception& e) {
54437       {
54438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54439       };
54440     } catch (Dali::DaliException e) {
54441       {
54442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54443       };
54444     } catch (...) {
54445       {
54446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54447       };
54448     }
54449   }
54450
54451   jresult = (unsigned long)result;
54452   return jresult;
54453 }
54454
54455
54456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54457   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54458   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54459
54460   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54461   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54462   {
54463     try {
54464       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54465     } catch (std::out_of_range& e) {
54466       {
54467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54468       };
54469     } catch (std::exception& e) {
54470       {
54471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54472       };
54473     } catch (Dali::DaliException e) {
54474       {
54475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54476       };
54477     } catch (...) {
54478       {
54479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54480       };
54481     }
54482   }
54483
54484 }
54485
54486
54487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54488   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54489   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54490
54491   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54492   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54493   {
54494     try {
54495       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54496     } catch (std::out_of_range& e) {
54497       {
54498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54499       };
54500     } catch (std::exception& e) {
54501       {
54502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54503       };
54504     } catch (Dali::DaliException e) {
54505       {
54506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54507       };
54508     } catch (...) {
54509       {
54510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54511       };
54512     }
54513   }
54514
54515 }
54516
54517
54518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54519   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54520   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54521
54522   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54523   arg2 = (Dali::RefObject *)jarg2;
54524   {
54525     try {
54526       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54527     } catch (std::out_of_range& e) {
54528       {
54529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54530       };
54531     } catch (std::exception& e) {
54532       {
54533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54534       };
54535     } catch (Dali::DaliException e) {
54536       {
54537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54538       };
54539     } catch (...) {
54540       {
54541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54542       };
54543     }
54544   }
54545
54546 }
54547
54548
54549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54550   void * jresult ;
54551   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54552
54553   {
54554     try {
54555       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54556     } catch (std::out_of_range& e) {
54557       {
54558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54559       };
54560     } catch (std::exception& e) {
54561       {
54562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54563       };
54564     } catch (Dali::DaliException e) {
54565       {
54566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54567       };
54568     } catch (...) {
54569       {
54570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54571       };
54572     }
54573   }
54574
54575   jresult = (void *)result;
54576   return jresult;
54577 }
54578
54579
54580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54581   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54582
54583   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54584   {
54585     try {
54586       delete arg1;
54587     } catch (std::out_of_range& e) {
54588       {
54589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54590       };
54591     } catch (std::exception& e) {
54592       {
54593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54594       };
54595     } catch (Dali::DaliException e) {
54596       {
54597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54598       };
54599     } catch (...) {
54600       {
54601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54602       };
54603     }
54604   }
54605
54606 }
54607
54608
54609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54610   unsigned int jresult ;
54611   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54612   bool result;
54613
54614   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54615   {
54616     try {
54617       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54618     } catch (std::out_of_range& e) {
54619       {
54620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54621       };
54622     } catch (std::exception& e) {
54623       {
54624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54625       };
54626     } catch (Dali::DaliException e) {
54627       {
54628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54629       };
54630     } catch (...) {
54631       {
54632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54633       };
54634     }
54635   }
54636
54637   jresult = result;
54638   return jresult;
54639 }
54640
54641
54642 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54643   unsigned long jresult ;
54644   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54645   std::size_t result;
54646
54647   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54648   {
54649     try {
54650       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54651     } catch (std::out_of_range& e) {
54652       {
54653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54654       };
54655     } catch (std::exception& e) {
54656       {
54657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54658       };
54659     } catch (Dali::DaliException e) {
54660       {
54661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54662       };
54663     } catch (...) {
54664       {
54665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54666       };
54667     }
54668   }
54669
54670   jresult = (unsigned long)result;
54671   return jresult;
54672 }
54673
54674
54675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54676   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54677   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54678
54679   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54680   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54681   {
54682     try {
54683       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54684     } catch (std::out_of_range& e) {
54685       {
54686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54687       };
54688     } catch (std::exception& e) {
54689       {
54690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54691       };
54692     } catch (Dali::DaliException e) {
54693       {
54694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54695       };
54696     } catch (...) {
54697       {
54698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54699       };
54700     }
54701   }
54702
54703 }
54704
54705
54706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54707   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54708   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54709
54710   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54711   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54712   {
54713     try {
54714       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54715     } catch (std::out_of_range& e) {
54716       {
54717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54718       };
54719     } catch (std::exception& e) {
54720       {
54721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54722       };
54723     } catch (Dali::DaliException e) {
54724       {
54725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54726       };
54727     } catch (...) {
54728       {
54729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54730       };
54731     }
54732   }
54733
54734 }
54735
54736
54737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54738   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54739   Dali::PropertyNotification *arg2 = 0 ;
54740
54741   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54742   arg2 = (Dali::PropertyNotification *)jarg2;
54743   if (!arg2) {
54744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54745     return ;
54746   }
54747   {
54748     try {
54749       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54750     } catch (std::out_of_range& e) {
54751       {
54752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54753       };
54754     } catch (std::exception& e) {
54755       {
54756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54757       };
54758     } catch (Dali::DaliException e) {
54759       {
54760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54761       };
54762     } catch (...) {
54763       {
54764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54765       };
54766     }
54767   }
54768
54769 }
54770
54771
54772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54773   void * jresult ;
54774   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54775
54776   {
54777     try {
54778       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54779     } catch (std::out_of_range& e) {
54780       {
54781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54782       };
54783     } catch (std::exception& e) {
54784       {
54785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54786       };
54787     } catch (Dali::DaliException e) {
54788       {
54789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54790       };
54791     } catch (...) {
54792       {
54793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54794       };
54795     }
54796   }
54797
54798   jresult = (void *)result;
54799   return jresult;
54800 }
54801
54802
54803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54804   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54805
54806   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54807   {
54808     try {
54809       delete arg1;
54810     } catch (std::out_of_range& e) {
54811       {
54812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54813       };
54814     } catch (std::exception& e) {
54815       {
54816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54817       };
54818     } catch (Dali::DaliException e) {
54819       {
54820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54821       };
54822     } catch (...) {
54823       {
54824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54825       };
54826     }
54827   }
54828
54829 }
54830
54831
54832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54833   unsigned int jresult ;
54834   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54835   bool result;
54836
54837   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54838   {
54839     try {
54840       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54841     } catch (std::out_of_range& e) {
54842       {
54843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54844       };
54845     } catch (std::exception& e) {
54846       {
54847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54848       };
54849     } catch (Dali::DaliException e) {
54850       {
54851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54852       };
54853     } catch (...) {
54854       {
54855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54856       };
54857     }
54858   }
54859
54860   jresult = result;
54861   return jresult;
54862 }
54863
54864
54865 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54866   unsigned long jresult ;
54867   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54868   std::size_t result;
54869
54870   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54871   {
54872     try {
54873       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54874     } catch (std::out_of_range& e) {
54875       {
54876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54877       };
54878     } catch (std::exception& e) {
54879       {
54880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54881       };
54882     } catch (Dali::DaliException e) {
54883       {
54884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54885       };
54886     } catch (...) {
54887       {
54888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54889       };
54890     }
54891   }
54892
54893   jresult = (unsigned long)result;
54894   return jresult;
54895 }
54896
54897
54898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54899   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54900   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54901
54902   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54903   arg2 = (void (*)(Dali::Image))jarg2;
54904   {
54905     try {
54906       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54907     } catch (std::out_of_range& e) {
54908       {
54909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54910       };
54911     } catch (std::exception& e) {
54912       {
54913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54914       };
54915     } catch (Dali::DaliException e) {
54916       {
54917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54918       };
54919     } catch (...) {
54920       {
54921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54922       };
54923     }
54924   }
54925
54926 }
54927
54928
54929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54930   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54931   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54932
54933   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54934   arg2 = (void (*)(Dali::Image))jarg2;
54935   {
54936     try {
54937       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54938     } catch (std::out_of_range& e) {
54939       {
54940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54941       };
54942     } catch (std::exception& e) {
54943       {
54944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54945       };
54946     } catch (Dali::DaliException e) {
54947       {
54948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54949       };
54950     } catch (...) {
54951       {
54952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54953       };
54954     }
54955   }
54956
54957 }
54958
54959
54960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54961   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54962   Dali::Image arg2 ;
54963   Dali::Image *argp2 ;
54964
54965   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54966   argp2 = (Dali::Image *)jarg2;
54967   if (!argp2) {
54968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54969     return ;
54970   }
54971   arg2 = *argp2;
54972   {
54973     try {
54974       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54975     } catch (std::out_of_range& e) {
54976       {
54977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54978       };
54979     } catch (std::exception& e) {
54980       {
54981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54982       };
54983     } catch (Dali::DaliException e) {
54984       {
54985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54986       };
54987     } catch (...) {
54988       {
54989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54990       };
54991     }
54992   }
54993
54994 }
54995
54996
54997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54998   void * jresult ;
54999   Dali::Signal< void (Dali::Image) > *result = 0 ;
55000
55001   {
55002     try {
55003       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55004     } catch (std::out_of_range& e) {
55005       {
55006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55007       };
55008     } catch (std::exception& e) {
55009       {
55010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55011       };
55012     } catch (Dali::DaliException e) {
55013       {
55014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55015       };
55016     } catch (...) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55019       };
55020     }
55021   }
55022
55023   jresult = (void *)result;
55024   return jresult;
55025 }
55026
55027
55028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55029   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55030
55031   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55032   {
55033     try {
55034       delete arg1;
55035     } catch (std::out_of_range& e) {
55036       {
55037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55038       };
55039     } catch (std::exception& e) {
55040       {
55041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55042       };
55043     } catch (Dali::DaliException e) {
55044       {
55045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55046       };
55047     } catch (...) {
55048       {
55049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55050       };
55051     }
55052   }
55053
55054 }
55055
55056
55057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55058   void * jresult ;
55059   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55060
55061   {
55062     try {
55063       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55064     } catch (std::out_of_range& e) {
55065       {
55066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55067       };
55068     } catch (std::exception& e) {
55069       {
55070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55071       };
55072     } catch (Dali::DaliException e) {
55073       {
55074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55075       };
55076     } catch (...) {
55077       {
55078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55079       };
55080     }
55081   }
55082
55083   jresult = (void *)result;
55084   return jresult;
55085 }
55086
55087
55088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55089   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55090
55091   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55092   {
55093     try {
55094       delete arg1;
55095     } catch (std::out_of_range& e) {
55096       {
55097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55098       };
55099     } catch (std::exception& e) {
55100       {
55101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55102       };
55103     } catch (Dali::DaliException e) {
55104       {
55105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55106       };
55107     } catch (...) {
55108       {
55109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55110       };
55111     }
55112   }
55113
55114 }
55115
55116
55117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55118   unsigned int jresult ;
55119   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55120   bool result;
55121
55122   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55123   {
55124     try {
55125       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
55126     } catch (std::out_of_range& e) {
55127       {
55128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55129       };
55130     } catch (std::exception& e) {
55131       {
55132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55133       };
55134     } catch (Dali::DaliException e) {
55135       {
55136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55137       };
55138     } catch (...) {
55139       {
55140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55141       };
55142     }
55143   }
55144
55145   jresult = result;
55146   return jresult;
55147 }
55148
55149
55150 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55151   unsigned long jresult ;
55152   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55153   std::size_t result;
55154
55155   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55156   {
55157     try {
55158       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
55159     } catch (std::out_of_range& e) {
55160       {
55161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55162       };
55163     } catch (std::exception& e) {
55164       {
55165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55166       };
55167     } catch (Dali::DaliException e) {
55168       {
55169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55170       };
55171     } catch (...) {
55172       {
55173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55174       };
55175     }
55176   }
55177
55178   jresult = (unsigned long)result;
55179   return jresult;
55180 }
55181
55182
55183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55184   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55185   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55186
55187   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55188   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55189   {
55190     try {
55191       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55192     } catch (std::out_of_range& e) {
55193       {
55194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55195       };
55196     } catch (std::exception& e) {
55197       {
55198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55199       };
55200     } catch (Dali::DaliException e) {
55201       {
55202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55203       };
55204     } catch (...) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55207       };
55208     }
55209   }
55210
55211 }
55212
55213
55214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55215   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55216   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55217
55218   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55219   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55220   {
55221     try {
55222       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55223     } catch (std::out_of_range& e) {
55224       {
55225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55226       };
55227     } catch (std::exception& e) {
55228       {
55229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55230       };
55231     } catch (Dali::DaliException e) {
55232       {
55233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55234       };
55235     } catch (...) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55238       };
55239     }
55240   }
55241
55242 }
55243
55244
55245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55246   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55247   Dali::Actor arg2 ;
55248   Dali::LongPressGesture *arg3 = 0 ;
55249   Dali::Actor *argp2 ;
55250
55251   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55252   argp2 = (Dali::Actor *)jarg2;
55253   if (!argp2) {
55254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55255     return ;
55256   }
55257   arg2 = *argp2;
55258   arg3 = (Dali::LongPressGesture *)jarg3;
55259   if (!arg3) {
55260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55261     return ;
55262   }
55263   {
55264     try {
55265       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55266     } catch (std::out_of_range& e) {
55267       {
55268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55269       };
55270     } catch (std::exception& e) {
55271       {
55272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55273       };
55274     } catch (Dali::DaliException e) {
55275       {
55276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55277       };
55278     } catch (...) {
55279       {
55280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55281       };
55282     }
55283   }
55284
55285 }
55286
55287
55288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55289   void * jresult ;
55290   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55291
55292   {
55293     try {
55294       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55295     } catch (std::out_of_range& e) {
55296       {
55297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55298       };
55299     } catch (std::exception& e) {
55300       {
55301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55302       };
55303     } catch (Dali::DaliException e) {
55304       {
55305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55306       };
55307     } catch (...) {
55308       {
55309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55310       };
55311     }
55312   }
55313
55314   jresult = (void *)result;
55315   return jresult;
55316 }
55317
55318
55319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55320   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55321
55322   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55323   {
55324     try {
55325       delete arg1;
55326     } catch (std::out_of_range& e) {
55327       {
55328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55329       };
55330     } catch (std::exception& e) {
55331       {
55332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55333       };
55334     } catch (Dali::DaliException e) {
55335       {
55336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55337       };
55338     } catch (...) {
55339       {
55340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55341       };
55342     }
55343   }
55344
55345 }
55346
55347
55348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55349   unsigned int jresult ;
55350   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55351   bool result;
55352
55353   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55354   {
55355     try {
55356       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
55357     } catch (std::out_of_range& e) {
55358       {
55359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55360       };
55361     } catch (std::exception& e) {
55362       {
55363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55364       };
55365     } catch (Dali::DaliException e) {
55366       {
55367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55368       };
55369     } catch (...) {
55370       {
55371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55372       };
55373     }
55374   }
55375
55376   jresult = result;
55377   return jresult;
55378 }
55379
55380
55381 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55382   unsigned long jresult ;
55383   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55384   std::size_t result;
55385
55386   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55387   {
55388     try {
55389       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
55390     } catch (std::out_of_range& e) {
55391       {
55392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55393       };
55394     } catch (std::exception& e) {
55395       {
55396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55397       };
55398     } catch (Dali::DaliException e) {
55399       {
55400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55401       };
55402     } catch (...) {
55403       {
55404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55405       };
55406     }
55407   }
55408
55409   jresult = (unsigned long)result;
55410   return jresult;
55411 }
55412
55413
55414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55415   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55416   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55417
55418   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55419   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55420   {
55421     try {
55422       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55423     } catch (std::out_of_range& e) {
55424       {
55425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55426       };
55427     } catch (std::exception& e) {
55428       {
55429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55430       };
55431     } catch (Dali::DaliException e) {
55432       {
55433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55434       };
55435     } catch (...) {
55436       {
55437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55438       };
55439     }
55440   }
55441
55442 }
55443
55444
55445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55446   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55447   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55448
55449   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55450   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55451   {
55452     try {
55453       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55454     } catch (std::out_of_range& e) {
55455       {
55456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55457       };
55458     } catch (std::exception& e) {
55459       {
55460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55461       };
55462     } catch (Dali::DaliException e) {
55463       {
55464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55465       };
55466     } catch (...) {
55467       {
55468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55469       };
55470     }
55471   }
55472
55473 }
55474
55475
55476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55477   unsigned int jresult ;
55478   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55479   Dali::Actor arg2 ;
55480   Dali::TouchData *arg3 = 0 ;
55481   Dali::Actor *argp2 ;
55482   bool result;
55483
55484   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55485   argp2 = (Dali::Actor *)jarg2;
55486   if (!argp2) {
55487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55488     return 0;
55489   }
55490   arg2 = *argp2;
55491   arg3 = (Dali::TouchData *)jarg3;
55492   if (!arg3) {
55493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55494     return 0;
55495   }
55496   {
55497     try {
55498       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55499     } catch (std::out_of_range& e) {
55500       {
55501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55502       };
55503     } catch (std::exception& e) {
55504       {
55505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55506       };
55507     } catch (Dali::DaliException e) {
55508       {
55509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55510       };
55511     } catch (...) {
55512       {
55513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55514       };
55515     }
55516   }
55517
55518   jresult = result;
55519   return jresult;
55520 }
55521
55522
55523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55524   void * jresult ;
55525   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55526
55527   {
55528     try {
55529       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55530     } catch (std::out_of_range& e) {
55531       {
55532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55533       };
55534     } catch (std::exception& e) {
55535       {
55536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55537       };
55538     } catch (Dali::DaliException e) {
55539       {
55540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55541       };
55542     } catch (...) {
55543       {
55544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55545       };
55546     }
55547   }
55548
55549   jresult = (void *)result;
55550   return jresult;
55551 }
55552
55553
55554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55555   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55556
55557   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55558   {
55559     try {
55560       delete arg1;
55561     } catch (std::out_of_range& e) {
55562       {
55563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55564       };
55565     } catch (std::exception& e) {
55566       {
55567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55568       };
55569     } catch (Dali::DaliException e) {
55570       {
55571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55572       };
55573     } catch (...) {
55574       {
55575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55576       };
55577     }
55578   }
55579
55580 }
55581
55582
55583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55584   unsigned int jresult ;
55585   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55586   bool result;
55587
55588   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55589   {
55590     try {
55591       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
55592     } catch (std::out_of_range& e) {
55593       {
55594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55595       };
55596     } catch (std::exception& e) {
55597       {
55598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55599       };
55600     } catch (Dali::DaliException e) {
55601       {
55602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55603       };
55604     } catch (...) {
55605       {
55606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55607       };
55608     }
55609   }
55610
55611   jresult = result;
55612   return jresult;
55613 }
55614
55615
55616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55617   unsigned long jresult ;
55618   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55619   std::size_t result;
55620
55621   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55622   {
55623     try {
55624       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *)arg1);
55625     } catch (std::out_of_range& e) {
55626       {
55627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55628       };
55629     } catch (std::exception& e) {
55630       {
55631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55632       };
55633     } catch (Dali::DaliException e) {
55634       {
55635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55636       };
55637     } catch (...) {
55638       {
55639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55640       };
55641     }
55642   }
55643
55644   jresult = (unsigned long)result;
55645   return jresult;
55646 }
55647
55648
55649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55650   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55651   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55652
55653   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55654   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55655   {
55656     try {
55657       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55658     } catch (std::out_of_range& e) {
55659       {
55660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55661       };
55662     } catch (std::exception& e) {
55663       {
55664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55665       };
55666     } catch (Dali::DaliException e) {
55667       {
55668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55669       };
55670     } catch (...) {
55671       {
55672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55673       };
55674     }
55675   }
55676
55677 }
55678
55679
55680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55681   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55682   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55683
55684   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55685   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55686   {
55687     try {
55688       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55689     } catch (std::out_of_range& e) {
55690       {
55691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55692       };
55693     } catch (std::exception& e) {
55694       {
55695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55696       };
55697     } catch (Dali::DaliException e) {
55698       {
55699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55700       };
55701     } catch (...) {
55702       {
55703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55704       };
55705     }
55706   }
55707
55708 }
55709
55710
55711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55712   unsigned int jresult ;
55713   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55714   Dali::Actor arg2 ;
55715   Dali::HoverEvent *arg3 = 0 ;
55716   Dali::Actor *argp2 ;
55717   bool result;
55718
55719   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55720   argp2 = (Dali::Actor *)jarg2;
55721   if (!argp2) {
55722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55723     return 0;
55724   }
55725   arg2 = *argp2;
55726   arg3 = (Dali::HoverEvent *)jarg3;
55727   if (!arg3) {
55728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55729     return 0;
55730   }
55731   {
55732     try {
55733       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55734     } catch (std::out_of_range& e) {
55735       {
55736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55737       };
55738     } catch (std::exception& e) {
55739       {
55740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55741       };
55742     } catch (Dali::DaliException e) {
55743       {
55744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55745       };
55746     } catch (...) {
55747       {
55748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55749       };
55750     }
55751   }
55752
55753   jresult = result;
55754   return jresult;
55755 }
55756
55757
55758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55759   void * jresult ;
55760   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55761
55762   {
55763     try {
55764       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55765     } catch (std::out_of_range& e) {
55766       {
55767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55768       };
55769     } catch (std::exception& e) {
55770       {
55771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55772       };
55773     } catch (Dali::DaliException e) {
55774       {
55775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55776       };
55777     } catch (...) {
55778       {
55779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55780       };
55781     }
55782   }
55783
55784   jresult = (void *)result;
55785   return jresult;
55786 }
55787
55788
55789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55790   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55791
55792   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55793   {
55794     try {
55795       delete arg1;
55796     } catch (std::out_of_range& e) {
55797       {
55798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55799       };
55800     } catch (std::exception& e) {
55801       {
55802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55803       };
55804     } catch (Dali::DaliException e) {
55805       {
55806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55807       };
55808     } catch (...) {
55809       {
55810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55811       };
55812     }
55813   }
55814
55815 }
55816
55817
55818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55819   unsigned int jresult ;
55820   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55821   bool result;
55822
55823   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55824   {
55825     try {
55826       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
55827     } catch (std::out_of_range& e) {
55828       {
55829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55830       };
55831     } catch (std::exception& e) {
55832       {
55833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55834       };
55835     } catch (Dali::DaliException e) {
55836       {
55837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55838       };
55839     } catch (...) {
55840       {
55841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55842       };
55843     }
55844   }
55845
55846   jresult = result;
55847   return jresult;
55848 }
55849
55850
55851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55852   unsigned long jresult ;
55853   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55854   std::size_t result;
55855
55856   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55857   {
55858     try {
55859       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *)arg1);
55860     } catch (std::out_of_range& e) {
55861       {
55862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55863       };
55864     } catch (std::exception& e) {
55865       {
55866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55867       };
55868     } catch (Dali::DaliException e) {
55869       {
55870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55871       };
55872     } catch (...) {
55873       {
55874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55875       };
55876     }
55877   }
55878
55879   jresult = (unsigned long)result;
55880   return jresult;
55881 }
55882
55883
55884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55885   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55886   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55887
55888   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55889   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55890   {
55891     try {
55892       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55893     } catch (std::out_of_range& e) {
55894       {
55895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55896       };
55897     } catch (std::exception& e) {
55898       {
55899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55900       };
55901     } catch (Dali::DaliException e) {
55902       {
55903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55904       };
55905     } catch (...) {
55906       {
55907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55908       };
55909     }
55910   }
55911
55912 }
55913
55914
55915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55916   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55917   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55918
55919   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55920   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55921   {
55922     try {
55923       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55924     } catch (std::out_of_range& e) {
55925       {
55926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55927       };
55928     } catch (std::exception& e) {
55929       {
55930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55931       };
55932     } catch (Dali::DaliException e) {
55933       {
55934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55935       };
55936     } catch (...) {
55937       {
55938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55939       };
55940     }
55941   }
55942
55943 }
55944
55945
55946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55947   unsigned int jresult ;
55948   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55949   Dali::Actor arg2 ;
55950   Dali::WheelEvent *arg3 = 0 ;
55951   Dali::Actor *argp2 ;
55952   bool result;
55953
55954   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55955   argp2 = (Dali::Actor *)jarg2;
55956   if (!argp2) {
55957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55958     return 0;
55959   }
55960   arg2 = *argp2;
55961   arg3 = (Dali::WheelEvent *)jarg3;
55962   if (!arg3) {
55963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55964     return 0;
55965   }
55966   {
55967     try {
55968       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55969     } catch (std::out_of_range& e) {
55970       {
55971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55972       };
55973     } catch (std::exception& e) {
55974       {
55975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55976       };
55977     } catch (Dali::DaliException e) {
55978       {
55979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55980       };
55981     } catch (...) {
55982       {
55983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55984       };
55985     }
55986   }
55987
55988   jresult = result;
55989   return jresult;
55990 }
55991
55992
55993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55994   void * jresult ;
55995   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55996
55997   {
55998     try {
55999       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56000     } catch (std::out_of_range& e) {
56001       {
56002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56003       };
56004     } catch (std::exception& e) {
56005       {
56006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56007       };
56008     } catch (Dali::DaliException e) {
56009       {
56010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56011       };
56012     } catch (...) {
56013       {
56014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56015       };
56016     }
56017   }
56018
56019   jresult = (void *)result;
56020   return jresult;
56021 }
56022
56023
56024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56025   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56026
56027   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56028   {
56029     try {
56030       delete arg1;
56031     } catch (std::out_of_range& e) {
56032       {
56033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56034       };
56035     } catch (std::exception& e) {
56036       {
56037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56038       };
56039     } catch (Dali::DaliException e) {
56040       {
56041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56042       };
56043     } catch (...) {
56044       {
56045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56046       };
56047     }
56048   }
56049
56050 }
56051
56052
56053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56054   unsigned int jresult ;
56055   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56056   bool result;
56057
56058   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56059   {
56060     try {
56061       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56062     } catch (std::out_of_range& e) {
56063       {
56064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56065       };
56066     } catch (std::exception& e) {
56067       {
56068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56069       };
56070     } catch (Dali::DaliException e) {
56071       {
56072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56073       };
56074     } catch (...) {
56075       {
56076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56077       };
56078     }
56079   }
56080
56081   jresult = result;
56082   return jresult;
56083 }
56084
56085
56086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56087   unsigned long jresult ;
56088   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56089   std::size_t result;
56090
56091   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56092   {
56093     try {
56094       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56095     } catch (std::out_of_range& e) {
56096       {
56097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56098       };
56099     } catch (std::exception& e) {
56100       {
56101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56102       };
56103     } catch (Dali::DaliException e) {
56104       {
56105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56106       };
56107     } catch (...) {
56108       {
56109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56110       };
56111     }
56112   }
56113
56114   jresult = (unsigned long)result;
56115   return jresult;
56116 }
56117
56118
56119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56120   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56121   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56122
56123   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56124   arg2 = (void (*)(Dali::Actor))jarg2;
56125   {
56126     try {
56127       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56128     } catch (std::out_of_range& e) {
56129       {
56130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56131       };
56132     } catch (std::exception& e) {
56133       {
56134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56135       };
56136     } catch (Dali::DaliException e) {
56137       {
56138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56139       };
56140     } catch (...) {
56141       {
56142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56143       };
56144     }
56145   }
56146
56147 }
56148
56149
56150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56151   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56152   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56153
56154   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56155   arg2 = (void (*)(Dali::Actor))jarg2;
56156   {
56157     try {
56158       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56159     } catch (std::out_of_range& e) {
56160       {
56161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56162       };
56163     } catch (std::exception& e) {
56164       {
56165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56166       };
56167     } catch (Dali::DaliException e) {
56168       {
56169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56170       };
56171     } catch (...) {
56172       {
56173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56174       };
56175     }
56176   }
56177
56178 }
56179
56180
56181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56182   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56183   Dali::Actor arg2 ;
56184   Dali::Actor *argp2 ;
56185
56186   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56187   argp2 = (Dali::Actor *)jarg2;
56188   if (!argp2) {
56189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56190     return ;
56191   }
56192   arg2 = *argp2;
56193   {
56194     try {
56195       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56196     } catch (std::out_of_range& e) {
56197       {
56198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56199       };
56200     } catch (std::exception& e) {
56201       {
56202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56203       };
56204     } catch (Dali::DaliException e) {
56205       {
56206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56207       };
56208     } catch (...) {
56209       {
56210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56211       };
56212     }
56213   }
56214
56215 }
56216
56217
56218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56219   void * jresult ;
56220   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56221
56222   {
56223     try {
56224       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56225     } catch (std::out_of_range& e) {
56226       {
56227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56228       };
56229     } catch (std::exception& e) {
56230       {
56231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56232       };
56233     } catch (Dali::DaliException e) {
56234       {
56235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56236       };
56237     } catch (...) {
56238       {
56239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56240       };
56241     }
56242   }
56243
56244   jresult = (void *)result;
56245   return jresult;
56246 }
56247
56248
56249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56250   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56251
56252   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56253   {
56254     try {
56255       delete arg1;
56256     } catch (std::out_of_range& e) {
56257       {
56258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56259       };
56260     } catch (std::exception& e) {
56261       {
56262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56263       };
56264     } catch (Dali::DaliException e) {
56265       {
56266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56267       };
56268     } catch (...) {
56269       {
56270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56271       };
56272     }
56273   }
56274
56275 }
56276
56277
56278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56279   unsigned int jresult ;
56280   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56281   bool result;
56282
56283   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56284   {
56285     try {
56286       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56287     } catch (std::out_of_range& e) {
56288       {
56289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (std::exception& e) {
56292       {
56293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56294       };
56295     } catch (Dali::DaliException e) {
56296       {
56297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56298       };
56299     } catch (...) {
56300       {
56301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56302       };
56303     }
56304   }
56305
56306   jresult = result;
56307   return jresult;
56308 }
56309
56310
56311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56312   unsigned long jresult ;
56313   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56314   std::size_t result;
56315
56316   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56317   {
56318     try {
56319       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56320     } catch (std::out_of_range& e) {
56321       {
56322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56323       };
56324     } catch (std::exception& e) {
56325       {
56326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56327       };
56328     } catch (Dali::DaliException e) {
56329       {
56330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56331       };
56332     } catch (...) {
56333       {
56334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56335       };
56336     }
56337   }
56338
56339   jresult = (unsigned long)result;
56340   return jresult;
56341 }
56342
56343
56344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56345   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56346   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56347
56348   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56349   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56350   {
56351     try {
56352       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56353     } catch (std::out_of_range& e) {
56354       {
56355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56356       };
56357     } catch (std::exception& e) {
56358       {
56359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56360       };
56361     } catch (Dali::DaliException e) {
56362       {
56363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56364       };
56365     } catch (...) {
56366       {
56367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56368       };
56369     }
56370   }
56371
56372 }
56373
56374
56375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56376   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56377   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56378
56379   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56380   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56381   {
56382     try {
56383       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56384     } catch (std::out_of_range& e) {
56385       {
56386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56387       };
56388     } catch (std::exception& e) {
56389       {
56390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56391       };
56392     } catch (Dali::DaliException e) {
56393       {
56394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56395       };
56396     } catch (...) {
56397       {
56398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56399       };
56400     }
56401   }
56402
56403 }
56404
56405
56406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56407   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56408   Dali::KeyEvent *arg2 = 0 ;
56409
56410   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56411   arg2 = (Dali::KeyEvent *)jarg2;
56412   if (!arg2) {
56413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56414     return ;
56415   }
56416   {
56417     try {
56418       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56419     } catch (std::out_of_range& e) {
56420       {
56421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56422       };
56423     } catch (std::exception& e) {
56424       {
56425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56426       };
56427     } catch (Dali::DaliException e) {
56428       {
56429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56430       };
56431     } catch (...) {
56432       {
56433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56434       };
56435     }
56436   }
56437
56438 }
56439
56440
56441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56442   void * jresult ;
56443   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56444
56445   {
56446     try {
56447       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56448     } catch (std::out_of_range& e) {
56449       {
56450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56451       };
56452     } catch (std::exception& e) {
56453       {
56454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56455       };
56456     } catch (Dali::DaliException e) {
56457       {
56458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56459       };
56460     } catch (...) {
56461       {
56462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56463       };
56464     }
56465   }
56466
56467   jresult = (void *)result;
56468   return jresult;
56469 }
56470
56471
56472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56473   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56474
56475   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56476   {
56477     try {
56478       delete arg1;
56479     } catch (std::out_of_range& e) {
56480       {
56481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56482       };
56483     } catch (std::exception& e) {
56484       {
56485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56486       };
56487     } catch (Dali::DaliException e) {
56488       {
56489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56490       };
56491     } catch (...) {
56492       {
56493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56494       };
56495     }
56496   }
56497
56498 }
56499
56500
56501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56502   unsigned int jresult ;
56503   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56504   bool result;
56505
56506   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56507   {
56508     try {
56509       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56510     } catch (std::out_of_range& e) {
56511       {
56512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56513       };
56514     } catch (std::exception& e) {
56515       {
56516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56517       };
56518     } catch (Dali::DaliException e) {
56519       {
56520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56521       };
56522     } catch (...) {
56523       {
56524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56525       };
56526     }
56527   }
56528
56529   jresult = result;
56530   return jresult;
56531 }
56532
56533
56534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56535   unsigned long jresult ;
56536   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56537   std::size_t result;
56538
56539   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56540   {
56541     try {
56542       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56543     } catch (std::out_of_range& e) {
56544       {
56545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56546       };
56547     } catch (std::exception& e) {
56548       {
56549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56550       };
56551     } catch (Dali::DaliException e) {
56552       {
56553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56554       };
56555     } catch (...) {
56556       {
56557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56558       };
56559     }
56560   }
56561
56562   jresult = (unsigned long)result;
56563   return jresult;
56564 }
56565
56566
56567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56568   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56569   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56570
56571   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56572   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56573   {
56574     try {
56575       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56576     } catch (std::out_of_range& e) {
56577       {
56578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56579       };
56580     } catch (std::exception& e) {
56581       {
56582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56583       };
56584     } catch (Dali::DaliException e) {
56585       {
56586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56587       };
56588     } catch (...) {
56589       {
56590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56591       };
56592     }
56593   }
56594
56595 }
56596
56597
56598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56599   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56600   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56601
56602   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56603   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56604   {
56605     try {
56606       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56607     } catch (std::out_of_range& e) {
56608       {
56609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56610       };
56611     } catch (std::exception& e) {
56612       {
56613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56614       };
56615     } catch (Dali::DaliException e) {
56616       {
56617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56618       };
56619     } catch (...) {
56620       {
56621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56622       };
56623     }
56624   }
56625
56626 }
56627
56628
56629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56630   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56631   Dali::TouchData *arg2 = 0 ;
56632
56633   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56634   arg2 = (Dali::TouchData *)jarg2;
56635   if (!arg2) {
56636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56637     return ;
56638   }
56639   {
56640     try {
56641       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56642     } catch (std::out_of_range& e) {
56643       {
56644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56645       };
56646     } catch (std::exception& e) {
56647       {
56648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56649       };
56650     } catch (Dali::DaliException e) {
56651       {
56652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56653       };
56654     } catch (...) {
56655       {
56656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56657       };
56658     }
56659   }
56660
56661 }
56662
56663
56664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56665   void * jresult ;
56666   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56667
56668   {
56669     try {
56670       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56671     } catch (std::out_of_range& e) {
56672       {
56673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56674       };
56675     } catch (std::exception& e) {
56676       {
56677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56678       };
56679     } catch (Dali::DaliException e) {
56680       {
56681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56682       };
56683     } catch (...) {
56684       {
56685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56686       };
56687     }
56688   }
56689
56690   jresult = (void *)result;
56691   return jresult;
56692 }
56693
56694
56695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56696   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56697
56698   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56699   {
56700     try {
56701       delete arg1;
56702     } catch (std::out_of_range& e) {
56703       {
56704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56705       };
56706     } catch (std::exception& e) {
56707       {
56708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56709       };
56710     } catch (Dali::DaliException e) {
56711       {
56712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56713       };
56714     } catch (...) {
56715       {
56716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56717       };
56718     }
56719   }
56720
56721 }
56722
56723
56724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56725   unsigned int jresult ;
56726   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56727   bool result;
56728
56729   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56730   {
56731     try {
56732       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56733     } catch (std::out_of_range& e) {
56734       {
56735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56736       };
56737     } catch (std::exception& e) {
56738       {
56739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56740       };
56741     } catch (Dali::DaliException e) {
56742       {
56743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56744       };
56745     } catch (...) {
56746       {
56747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56748       };
56749     }
56750   }
56751
56752   jresult = result;
56753   return jresult;
56754 }
56755
56756
56757 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56758   unsigned long jresult ;
56759   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56760   std::size_t result;
56761
56762   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56763   {
56764     try {
56765       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56766     } catch (std::out_of_range& e) {
56767       {
56768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56769       };
56770     } catch (std::exception& e) {
56771       {
56772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56773       };
56774     } catch (Dali::DaliException e) {
56775       {
56776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56777       };
56778     } catch (...) {
56779       {
56780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56781       };
56782     }
56783   }
56784
56785   jresult = (unsigned long)result;
56786   return jresult;
56787 }
56788
56789
56790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56791   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56792   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56793
56794   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56795   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56796   {
56797     try {
56798       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56799     } catch (std::out_of_range& e) {
56800       {
56801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56802       };
56803     } catch (std::exception& e) {
56804       {
56805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56806       };
56807     } catch (Dali::DaliException e) {
56808       {
56809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56810       };
56811     } catch (...) {
56812       {
56813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56814       };
56815     }
56816   }
56817
56818 }
56819
56820
56821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56822   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56823   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56824
56825   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56826   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56827   {
56828     try {
56829       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56830     } catch (std::out_of_range& e) {
56831       {
56832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56833       };
56834     } catch (std::exception& e) {
56835       {
56836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56837       };
56838     } catch (Dali::DaliException e) {
56839       {
56840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56841       };
56842     } catch (...) {
56843       {
56844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56845       };
56846     }
56847   }
56848
56849 }
56850
56851
56852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56853   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56854   Dali::WheelEvent *arg2 = 0 ;
56855
56856   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56857   arg2 = (Dali::WheelEvent *)jarg2;
56858   if (!arg2) {
56859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56860     return ;
56861   }
56862   {
56863     try {
56864       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56865     } catch (std::out_of_range& e) {
56866       {
56867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56868       };
56869     } catch (std::exception& e) {
56870       {
56871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56872       };
56873     } catch (Dali::DaliException e) {
56874       {
56875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56876       };
56877     } catch (...) {
56878       {
56879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56880       };
56881     }
56882   }
56883
56884 }
56885
56886
56887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56888   void * jresult ;
56889   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56890
56891   {
56892     try {
56893       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56894     } catch (std::out_of_range& e) {
56895       {
56896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56897       };
56898     } catch (std::exception& e) {
56899       {
56900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56901       };
56902     } catch (Dali::DaliException e) {
56903       {
56904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56905       };
56906     } catch (...) {
56907       {
56908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56909       };
56910     }
56911   }
56912
56913   jresult = (void *)result;
56914   return jresult;
56915 }
56916
56917
56918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56919   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56920
56921   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56922   {
56923     try {
56924       delete arg1;
56925     } catch (std::out_of_range& e) {
56926       {
56927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56928       };
56929     } catch (std::exception& e) {
56930       {
56931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56932       };
56933     } catch (Dali::DaliException e) {
56934       {
56935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56936       };
56937     } catch (...) {
56938       {
56939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56940       };
56941     }
56942   }
56943
56944 }
56945
56946
56947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56948   void * jresult ;
56949   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56950
56951   {
56952     try {
56953       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56954     } catch (std::out_of_range& e) {
56955       {
56956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56957       };
56958     } catch (std::exception& e) {
56959       {
56960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56961       };
56962     } catch (Dali::DaliException e) {
56963       {
56964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56965       };
56966     } catch (...) {
56967       {
56968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56969       };
56970     }
56971   }
56972
56973   jresult = (void *)result;
56974   return jresult;
56975 }
56976
56977
56978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56979   void * jresult ;
56980   Dali::Radian arg1 ;
56981   Dali::Radian arg2 ;
56982   Dali::Radian *argp1 ;
56983   Dali::Radian *argp2 ;
56984   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56985
56986   argp1 = (Dali::Radian *)jarg1;
56987   if (!argp1) {
56988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56989     return 0;
56990   }
56991   arg1 = *argp1;
56992   argp2 = (Dali::Radian *)jarg2;
56993   if (!argp2) {
56994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56995     return 0;
56996   }
56997   arg2 = *argp2;
56998   {
56999     try {
57000       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57001     } catch (std::out_of_range& e) {
57002       {
57003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57004       };
57005     } catch (std::exception& e) {
57006       {
57007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (Dali::DaliException e) {
57010       {
57011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57012       };
57013     } catch (...) {
57014       {
57015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57016       };
57017     }
57018   }
57019
57020   jresult = (void *)result;
57021   return jresult;
57022 }
57023
57024
57025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57026   void * jresult ;
57027   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57028   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57029
57030   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57031   if (!arg1) {
57032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57033     return 0;
57034   }
57035   {
57036     try {
57037       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57038     } catch (std::out_of_range& e) {
57039       {
57040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57041       };
57042     } catch (std::exception& e) {
57043       {
57044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57045       };
57046     } catch (Dali::DaliException e) {
57047       {
57048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57049       };
57050     } catch (...) {
57051       {
57052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57053       };
57054     }
57055   }
57056
57057   jresult = (void *)result;
57058   return jresult;
57059 }
57060
57061
57062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57063   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57064   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57065
57066   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57067   arg2 = (Dali::Radian *)jarg2;
57068   if (arg1) (arg1)->first = *arg2;
57069 }
57070
57071
57072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57073   void * jresult ;
57074   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57075   Dali::Radian *result = 0 ;
57076
57077   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57078   result = (Dali::Radian *)& ((arg1)->first);
57079   jresult = (void *)result;
57080   return jresult;
57081 }
57082
57083
57084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57085   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57086   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57087
57088   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57089   arg2 = (Dali::Radian *)jarg2;
57090   if (arg1) (arg1)->second = *arg2;
57091 }
57092
57093
57094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57095   void * jresult ;
57096   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57097   Dali::Radian *result = 0 ;
57098
57099   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57100   result = (Dali::Radian *)& ((arg1)->second);
57101   jresult = (void *)result;
57102   return jresult;
57103 }
57104
57105
57106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57107   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57108
57109   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57110   {
57111     try {
57112       delete arg1;
57113     } catch (std::out_of_range& e) {
57114       {
57115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57116       };
57117     } catch (std::exception& e) {
57118       {
57119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57120       };
57121     } catch (Dali::DaliException e) {
57122       {
57123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57124       };
57125     } catch (...) {
57126       {
57127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57128       };
57129     }
57130   }
57131
57132 }
57133
57134
57135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57136   unsigned int jresult ;
57137   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57138   bool result;
57139
57140   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57141   {
57142     try {
57143       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
57144     } catch (std::out_of_range& e) {
57145       {
57146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57147       };
57148     } catch (std::exception& e) {
57149       {
57150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57151       };
57152     } catch (Dali::DaliException e) {
57153       {
57154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57155       };
57156     } catch (...) {
57157       {
57158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57159       };
57160     }
57161   }
57162
57163   jresult = result;
57164   return jresult;
57165 }
57166
57167
57168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57169   unsigned long jresult ;
57170   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57171   std::size_t result;
57172
57173   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57174   {
57175     try {
57176       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *)arg1);
57177     } catch (std::out_of_range& e) {
57178       {
57179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57180       };
57181     } catch (std::exception& e) {
57182       {
57183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57184       };
57185     } catch (Dali::DaliException e) {
57186       {
57187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57188       };
57189     } catch (...) {
57190       {
57191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57192       };
57193     }
57194   }
57195
57196   jresult = (unsigned long)result;
57197   return jresult;
57198 }
57199
57200
57201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57202   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57203   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57204
57205   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57206   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57207   {
57208     try {
57209       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57210     } catch (std::out_of_range& e) {
57211       {
57212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57213       };
57214     } catch (std::exception& e) {
57215       {
57216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57217       };
57218     } catch (Dali::DaliException e) {
57219       {
57220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57221       };
57222     } catch (...) {
57223       {
57224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57225       };
57226     }
57227   }
57228
57229 }
57230
57231
57232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57233   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57234   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57235
57236   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57237   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57238   {
57239     try {
57240       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57241     } catch (std::out_of_range& e) {
57242       {
57243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57244       };
57245     } catch (std::exception& e) {
57246       {
57247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57248       };
57249     } catch (Dali::DaliException e) {
57250       {
57251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57252       };
57253     } catch (...) {
57254       {
57255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57256       };
57257     }
57258   }
57259
57260 }
57261
57262
57263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57264   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57265   Dali::Actor arg2 ;
57266   Dali::PanGesture *arg3 = 0 ;
57267   Dali::Actor *argp2 ;
57268
57269   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57270   argp2 = (Dali::Actor *)jarg2;
57271   if (!argp2) {
57272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57273     return ;
57274   }
57275   arg2 = *argp2;
57276   arg3 = (Dali::PanGesture *)jarg3;
57277   if (!arg3) {
57278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57279     return ;
57280   }
57281   {
57282     try {
57283       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57284     } catch (std::out_of_range& e) {
57285       {
57286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57287       };
57288     } catch (std::exception& e) {
57289       {
57290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57291       };
57292     } catch (Dali::DaliException e) {
57293       {
57294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57295       };
57296     } catch (...) {
57297       {
57298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57299       };
57300     }
57301   }
57302
57303 }
57304
57305
57306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57307   void * jresult ;
57308   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57309
57310   {
57311     try {
57312       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57313     } catch (std::out_of_range& e) {
57314       {
57315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57316       };
57317     } catch (std::exception& e) {
57318       {
57319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (Dali::DaliException e) {
57322       {
57323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57324       };
57325     } catch (...) {
57326       {
57327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57328       };
57329     }
57330   }
57331
57332   jresult = (void *)result;
57333   return jresult;
57334 }
57335
57336
57337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57338   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57339
57340   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57341   {
57342     try {
57343       delete arg1;
57344     } catch (std::out_of_range& e) {
57345       {
57346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57347       };
57348     } catch (std::exception& e) {
57349       {
57350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57351       };
57352     } catch (Dali::DaliException e) {
57353       {
57354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57355       };
57356     } catch (...) {
57357       {
57358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57359       };
57360     }
57361   }
57362
57363 }
57364
57365
57366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57367   unsigned int jresult ;
57368   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57369   bool result;
57370
57371   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57372   {
57373     try {
57374       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
57375     } catch (std::out_of_range& e) {
57376       {
57377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57378       };
57379     } catch (std::exception& e) {
57380       {
57381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57382       };
57383     } catch (Dali::DaliException e) {
57384       {
57385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57386       };
57387     } catch (...) {
57388       {
57389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57390       };
57391     }
57392   }
57393
57394   jresult = result;
57395   return jresult;
57396 }
57397
57398
57399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57400   unsigned long jresult ;
57401   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57402   std::size_t result;
57403
57404   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57405   {
57406     try {
57407       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *)arg1);
57408     } catch (std::out_of_range& e) {
57409       {
57410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57411       };
57412     } catch (std::exception& e) {
57413       {
57414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57415       };
57416     } catch (Dali::DaliException e) {
57417       {
57418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57419       };
57420     } catch (...) {
57421       {
57422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57423       };
57424     }
57425   }
57426
57427   jresult = (unsigned long)result;
57428   return jresult;
57429 }
57430
57431
57432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57433   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57434   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57435
57436   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57437   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57438   {
57439     try {
57440       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57441     } catch (std::out_of_range& e) {
57442       {
57443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57444       };
57445     } catch (std::exception& e) {
57446       {
57447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57448       };
57449     } catch (Dali::DaliException e) {
57450       {
57451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57452       };
57453     } catch (...) {
57454       {
57455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57456       };
57457     }
57458   }
57459
57460 }
57461
57462
57463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57464   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57465   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57466
57467   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57468   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57469   {
57470     try {
57471       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57472     } catch (std::out_of_range& e) {
57473       {
57474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57475       };
57476     } catch (std::exception& e) {
57477       {
57478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57479       };
57480     } catch (Dali::DaliException e) {
57481       {
57482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57483       };
57484     } catch (...) {
57485       {
57486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57487       };
57488     }
57489   }
57490
57491 }
57492
57493
57494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57495   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57496   Dali::Actor arg2 ;
57497   Dali::PinchGesture *arg3 = 0 ;
57498   Dali::Actor *argp2 ;
57499
57500   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57501   argp2 = (Dali::Actor *)jarg2;
57502   if (!argp2) {
57503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57504     return ;
57505   }
57506   arg2 = *argp2;
57507   arg3 = (Dali::PinchGesture *)jarg3;
57508   if (!arg3) {
57509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57510     return ;
57511   }
57512   {
57513     try {
57514       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57515     } catch (std::out_of_range& e) {
57516       {
57517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57518       };
57519     } catch (std::exception& e) {
57520       {
57521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57522       };
57523     } catch (Dali::DaliException e) {
57524       {
57525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57526       };
57527     } catch (...) {
57528       {
57529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57530       };
57531     }
57532   }
57533
57534 }
57535
57536
57537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57538   void * jresult ;
57539   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57540
57541   {
57542     try {
57543       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57544     } catch (std::out_of_range& e) {
57545       {
57546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57547       };
57548     } catch (std::exception& e) {
57549       {
57550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57551       };
57552     } catch (Dali::DaliException e) {
57553       {
57554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57555       };
57556     } catch (...) {
57557       {
57558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57559       };
57560     }
57561   }
57562
57563   jresult = (void *)result;
57564   return jresult;
57565 }
57566
57567
57568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57569   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57570
57571   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57572   {
57573     try {
57574       delete arg1;
57575     } catch (std::out_of_range& e) {
57576       {
57577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57578       };
57579     } catch (std::exception& e) {
57580       {
57581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57582       };
57583     } catch (Dali::DaliException e) {
57584       {
57585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57586       };
57587     } catch (...) {
57588       {
57589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57590       };
57591     }
57592   }
57593
57594 }
57595
57596
57597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57598   unsigned int jresult ;
57599   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57600   bool result;
57601
57602   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57603   {
57604     try {
57605       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
57606     } catch (std::out_of_range& e) {
57607       {
57608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57609       };
57610     } catch (std::exception& e) {
57611       {
57612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57613       };
57614     } catch (Dali::DaliException e) {
57615       {
57616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57617       };
57618     } catch (...) {
57619       {
57620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57621       };
57622     }
57623   }
57624
57625   jresult = result;
57626   return jresult;
57627 }
57628
57629
57630 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57631   unsigned long jresult ;
57632   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57633   std::size_t result;
57634
57635   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57636   {
57637     try {
57638       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *)arg1);
57639     } catch (std::out_of_range& e) {
57640       {
57641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57642       };
57643     } catch (std::exception& e) {
57644       {
57645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57646       };
57647     } catch (Dali::DaliException e) {
57648       {
57649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57650       };
57651     } catch (...) {
57652       {
57653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57654       };
57655     }
57656   }
57657
57658   jresult = (unsigned long)result;
57659   return jresult;
57660 }
57661
57662
57663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57664   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57665   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57666
57667   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57668   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57669   {
57670     try {
57671       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57672     } catch (std::out_of_range& e) {
57673       {
57674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57675       };
57676     } catch (std::exception& e) {
57677       {
57678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57679       };
57680     } catch (Dali::DaliException e) {
57681       {
57682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57683       };
57684     } catch (...) {
57685       {
57686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57687       };
57688     }
57689   }
57690
57691 }
57692
57693
57694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57695   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57696   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57697
57698   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57699   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57700   {
57701     try {
57702       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57703     } catch (std::out_of_range& e) {
57704       {
57705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57706       };
57707     } catch (std::exception& e) {
57708       {
57709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57710       };
57711     } catch (Dali::DaliException e) {
57712       {
57713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57714       };
57715     } catch (...) {
57716       {
57717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57718       };
57719     }
57720   }
57721
57722 }
57723
57724
57725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57726   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57727   Dali::Actor arg2 ;
57728   Dali::TapGesture *arg3 = 0 ;
57729   Dali::Actor *argp2 ;
57730
57731   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57732   argp2 = (Dali::Actor *)jarg2;
57733   if (!argp2) {
57734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57735     return ;
57736   }
57737   arg2 = *argp2;
57738   arg3 = (Dali::TapGesture *)jarg3;
57739   if (!arg3) {
57740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57741     return ;
57742   }
57743   {
57744     try {
57745       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57746     } catch (std::out_of_range& e) {
57747       {
57748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57749       };
57750     } catch (std::exception& e) {
57751       {
57752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57753       };
57754     } catch (Dali::DaliException e) {
57755       {
57756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57757       };
57758     } catch (...) {
57759       {
57760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57761       };
57762     }
57763   }
57764
57765 }
57766
57767
57768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57769   void * jresult ;
57770   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57771
57772   {
57773     try {
57774       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57775     } catch (std::out_of_range& e) {
57776       {
57777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57778       };
57779     } catch (std::exception& e) {
57780       {
57781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57782       };
57783     } catch (Dali::DaliException e) {
57784       {
57785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57786       };
57787     } catch (...) {
57788       {
57789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57790       };
57791     }
57792   }
57793
57794   jresult = (void *)result;
57795   return jresult;
57796 }
57797
57798
57799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57800   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57801
57802   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57803   {
57804     try {
57805       delete arg1;
57806     } catch (std::out_of_range& e) {
57807       {
57808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57809       };
57810     } catch (std::exception& e) {
57811       {
57812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57813       };
57814     } catch (Dali::DaliException e) {
57815       {
57816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57817       };
57818     } catch (...) {
57819       {
57820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57821       };
57822     }
57823   }
57824
57825 }
57826
57827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57828   unsigned int jresult ;
57829   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57830   bool result;
57831
57832   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57833   {
57834     try {
57835       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57836     } catch (std::out_of_range& e) {
57837       {
57838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57839       };
57840     } catch (std::exception& e) {
57841       {
57842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57843       };
57844     } catch (Dali::DaliException e) {
57845       {
57846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57847       };
57848     } catch (...) {
57849       {
57850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57851       };
57852     }
57853   }
57854
57855   jresult = result;
57856   return jresult;
57857 }
57858
57859
57860 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57861   unsigned long jresult ;
57862   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57863   std::size_t result;
57864
57865   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57866   {
57867     try {
57868       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57869     } catch (std::out_of_range& e) {
57870       {
57871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57872       };
57873     } catch (std::exception& e) {
57874       {
57875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57876       };
57877     } catch (Dali::DaliException e) {
57878       {
57879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57880       };
57881     } catch (...) {
57882       {
57883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57884       };
57885     }
57886   }
57887
57888   jresult = (unsigned long)result;
57889   return jresult;
57890 }
57891
57892
57893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57894   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57895   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57896
57897   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57898   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57899   {
57900     try {
57901       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57902     } catch (std::out_of_range& e) {
57903       {
57904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57905       };
57906     } catch (std::exception& e) {
57907       {
57908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57909       };
57910     } catch (Dali::DaliException e) {
57911       {
57912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57913       };
57914     } catch (...) {
57915       {
57916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57917       };
57918     }
57919   }
57920
57921 }
57922
57923
57924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57925   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57926   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57927
57928   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57929   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57930   {
57931     try {
57932       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57933     } catch (std::out_of_range& e) {
57934       {
57935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57936       };
57937     } catch (std::exception& e) {
57938       {
57939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57940       };
57941     } catch (Dali::DaliException e) {
57942       {
57943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57944       };
57945     } catch (...) {
57946       {
57947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57948       };
57949     }
57950   }
57951
57952 }
57953
57954
57955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57956   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57957   Dali::ResourceImage arg2 ;
57958   Dali::ResourceImage *argp2 ;
57959
57960   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57961   argp2 = (Dali::ResourceImage *)jarg2;
57962   if (!argp2) {
57963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57964     return ;
57965   }
57966   arg2 = *argp2;
57967   {
57968     try {
57969       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57970     } catch (std::out_of_range& e) {
57971       {
57972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57973       };
57974     } catch (std::exception& e) {
57975       {
57976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57977       };
57978     } catch (Dali::DaliException e) {
57979       {
57980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57981       };
57982     } catch (...) {
57983       {
57984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57985       };
57986     }
57987   }
57988
57989 }
57990
57991
57992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57993   void * jresult ;
57994   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57995
57996   {
57997     try {
57998       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57999     } catch (std::out_of_range& e) {
58000       {
58001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58002       };
58003     } catch (std::exception& e) {
58004       {
58005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58006       };
58007     } catch (Dali::DaliException e) {
58008       {
58009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58010       };
58011     } catch (...) {
58012       {
58013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58014       };
58015     }
58016   }
58017
58018   jresult = (void *)result;
58019   return jresult;
58020 }
58021
58022
58023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58024   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58025
58026   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58027   {
58028     try {
58029       delete arg1;
58030     } catch (std::out_of_range& e) {
58031       {
58032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58033       };
58034     } catch (std::exception& e) {
58035       {
58036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58037       };
58038     } catch (Dali::DaliException e) {
58039       {
58040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58041       };
58042     } catch (...) {
58043       {
58044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58045       };
58046     }
58047   }
58048
58049 }
58050
58051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58052   unsigned int jresult ;
58053   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58054   bool result = false;
58055
58056   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58057   {
58058     try {
58059       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
58060     } catch (std::out_of_range& e) {
58061       {
58062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58063       };
58064     } catch (std::exception& e) {
58065       {
58066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58067       };
58068     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58069   }
58070   jresult = result;
58071   return jresult;
58072 }
58073
58074 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58075   unsigned long jresult ;
58076   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58077   std::size_t result = 0;
58078
58079   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58080   {
58081     try {
58082       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
58083     } catch (std::out_of_range& e) {
58084       {
58085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58086       };
58087     } catch (std::exception& e) {
58088       {
58089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58090       };
58091     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58092   }
58093   jresult = (unsigned long)result;
58094   return jresult;
58095 }
58096
58097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58098   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58099   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58100
58101   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58102   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58103   {
58104     try {
58105       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58106     } catch (std::out_of_range& e) {
58107       {
58108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58109       };
58110     } catch (std::exception& e) {
58111       {
58112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58113       };
58114     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58115   }
58116 }
58117
58118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58119   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58120   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58121
58122   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58123   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58124   {
58125     try {
58126       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58127     } catch (std::out_of_range& e) {
58128       {
58129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58130       };
58131     } catch (std::exception& e) {
58132       {
58133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58134       };
58135     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58136   }
58137 }
58138
58139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58140   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58141   Dali::Actor arg2 ;
58142   //bool arg3 ;
58143   Dali::LayoutDirection::Type arg4 ;
58144   Dali::Actor *argp2 ;
58145
58146   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58147   argp2 = (Dali::Actor *)jarg2;
58148   if (!argp2) {
58149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58150     return ;
58151   }
58152   arg2 = *argp2;
58153   //arg3 = jarg3 ? true : false;
58154   arg4 = (Dali::LayoutDirection::Type)jarg4;
58155   {
58156     try {
58157       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58158     } catch (std::out_of_range& e) {
58159       {
58160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58161       };
58162     } catch (std::exception& e) {
58163       {
58164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58165       };
58166     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58167   }
58168 }
58169
58170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58171   void * jresult ;
58172   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58173
58174   {
58175     try {
58176       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58177     } catch (std::out_of_range& e) {
58178       {
58179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58180       };
58181     } catch (std::exception& e) {
58182       {
58183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58184       };
58185     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58186   }
58187   jresult = (void *)result;
58188   return jresult;
58189 }
58190
58191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58192   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58193
58194   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58195   {
58196     try {
58197       delete arg1;
58198     } catch (std::out_of_range& e) {
58199       {
58200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58201       };
58202     } catch (std::exception& e) {
58203       {
58204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58205       };
58206     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58207   }
58208 }
58209
58210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58211   unsigned int jresult ;
58212   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58213   bool result;
58214
58215   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58216   {
58217     try {
58218       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
58219     } catch (std::out_of_range& e) {
58220       {
58221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58222       };
58223     } catch (std::exception& e) {
58224       {
58225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58226       };
58227     } catch (Dali::DaliException e) {
58228       {
58229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58230       };
58231     } catch (...) {
58232       {
58233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58234       };
58235     }
58236   }
58237
58238   jresult = result;
58239   return jresult;
58240 }
58241
58242
58243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58244   unsigned long jresult ;
58245   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58246   std::size_t result;
58247
58248   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58249   {
58250     try {
58251       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
58252     } catch (std::out_of_range& e) {
58253       {
58254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (std::exception& e) {
58257       {
58258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (Dali::DaliException e) {
58261       {
58262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58263       };
58264     } catch (...) {
58265       {
58266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58267       };
58268     }
58269   }
58270
58271   jresult = (unsigned long)result;
58272   return jresult;
58273 }
58274
58275
58276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58277   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58278   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58279
58280   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58281   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58282   {
58283     try {
58284       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58285     } catch (std::out_of_range& e) {
58286       {
58287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58288       };
58289     } catch (std::exception& e) {
58290       {
58291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58292       };
58293     } catch (Dali::DaliException e) {
58294       {
58295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58296       };
58297     } catch (...) {
58298       {
58299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58300       };
58301     }
58302   }
58303
58304 }
58305
58306
58307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58308   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58309   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58310
58311   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58312   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58313   {
58314     try {
58315       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58316     } catch (std::out_of_range& e) {
58317       {
58318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58319       };
58320     } catch (std::exception& e) {
58321       {
58322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58323       };
58324     } catch (Dali::DaliException e) {
58325       {
58326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58327       };
58328     } catch (...) {
58329       {
58330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58331       };
58332     }
58333   }
58334
58335 }
58336
58337
58338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58339   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58340   Dali::Actor arg2 ;
58341   bool arg3 ;
58342   Dali::DevelActor::VisibilityChange::Type arg4 ;
58343   Dali::Actor *argp2 ;
58344
58345   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58346   argp2 = (Dali::Actor *)jarg2;
58347   if (!argp2) {
58348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58349     return ;
58350   }
58351   arg2 = *argp2;
58352   arg3 = jarg3 ? true : false;
58353   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58354   {
58355     try {
58356       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58357     } catch (std::out_of_range& e) {
58358       {
58359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58360       };
58361     } catch (std::exception& e) {
58362       {
58363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58364       };
58365     } catch (Dali::DaliException e) {
58366       {
58367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58368       };
58369     } catch (...) {
58370       {
58371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58372       };
58373     }
58374   }
58375
58376 }
58377
58378
58379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58380   void * jresult ;
58381   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58382
58383   {
58384     try {
58385       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58386     } catch (std::out_of_range& e) {
58387       {
58388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58389       };
58390     } catch (std::exception& e) {
58391       {
58392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58393       };
58394     } catch (Dali::DaliException e) {
58395       {
58396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58397       };
58398     } catch (...) {
58399       {
58400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58401       };
58402     }
58403   }
58404
58405   jresult = (void *)result;
58406   return jresult;
58407 }
58408
58409
58410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58411   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58412
58413   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58414   {
58415     try {
58416       delete arg1;
58417     } catch (std::out_of_range& e) {
58418       {
58419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58420       };
58421     } catch (std::exception& e) {
58422       {
58423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58424       };
58425     } catch (Dali::DaliException e) {
58426       {
58427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58428       };
58429     } catch (...) {
58430       {
58431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58432       };
58433     }
58434   }
58435
58436 }
58437
58438
58439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58440   void * jresult ;
58441   Dali::Timer *result = 0 ;
58442
58443   {
58444     try {
58445       result = (Dali::Timer *)new Dali::Timer();
58446     } catch (std::out_of_range& e) {
58447       {
58448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58449       };
58450     } catch (std::exception& e) {
58451       {
58452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58453       };
58454     } catch (Dali::DaliException e) {
58455       {
58456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58457       };
58458     } catch (...) {
58459       {
58460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58461       };
58462     }
58463   }
58464
58465   jresult = (void *)result;
58466   return jresult;
58467 }
58468
58469
58470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58471   void * jresult ;
58472   unsigned int arg1 ;
58473   Dali::Timer result;
58474
58475   arg1 = (unsigned int)jarg1;
58476   {
58477     try {
58478       result = Dali::Timer::New(arg1);
58479     } catch (std::out_of_range& e) {
58480       {
58481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58482       };
58483     } catch (std::exception& e) {
58484       {
58485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58486       };
58487     } catch (Dali::DaliException e) {
58488       {
58489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58490       };
58491     } catch (...) {
58492       {
58493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58494       };
58495     }
58496   }
58497
58498   jresult = new Dali::Timer((const Dali::Timer &)result);
58499   return jresult;
58500 }
58501
58502
58503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58504   void * jresult ;
58505   Dali::Timer *arg1 = 0 ;
58506   Dali::Timer *result = 0 ;
58507
58508   arg1 = (Dali::Timer *)jarg1;
58509   if (!arg1) {
58510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58511     return 0;
58512   }
58513   {
58514     try {
58515       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58516     } catch (std::out_of_range& e) {
58517       {
58518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58519       };
58520     } catch (std::exception& e) {
58521       {
58522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58523       };
58524     } catch (Dali::DaliException e) {
58525       {
58526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58527       };
58528     } catch (...) {
58529       {
58530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58531       };
58532     }
58533   }
58534
58535   jresult = (void *)result;
58536   return jresult;
58537 }
58538
58539
58540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58541   void * jresult ;
58542   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58543   Dali::Timer *arg2 = 0 ;
58544   Dali::Timer *result = 0 ;
58545
58546   arg1 = (Dali::Timer *)jarg1;
58547   arg2 = (Dali::Timer *)jarg2;
58548   if (!arg2) {
58549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58550     return 0;
58551   }
58552   {
58553     try {
58554       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58555     } catch (std::out_of_range& e) {
58556       {
58557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58558       };
58559     } catch (std::exception& e) {
58560       {
58561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58562       };
58563     } catch (Dali::DaliException e) {
58564       {
58565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58566       };
58567     } catch (...) {
58568       {
58569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58570       };
58571     }
58572   }
58573
58574   jresult = (void *)result;
58575   return jresult;
58576 }
58577
58578
58579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58580   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58581
58582   arg1 = (Dali::Timer *)jarg1;
58583   {
58584     try {
58585       delete arg1;
58586     } catch (std::out_of_range& e) {
58587       {
58588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58589       };
58590     } catch (std::exception& e) {
58591       {
58592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58593       };
58594     } catch (Dali::DaliException e) {
58595       {
58596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58597       };
58598     } catch (...) {
58599       {
58600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58601       };
58602     }
58603   }
58604
58605 }
58606
58607
58608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58609   void * jresult ;
58610   Dali::BaseHandle arg1 ;
58611   Dali::BaseHandle *argp1 ;
58612   Dali::Timer result;
58613
58614   argp1 = (Dali::BaseHandle *)jarg1;
58615   if (!argp1) {
58616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58617     return 0;
58618   }
58619   arg1 = *argp1;
58620   {
58621     try {
58622       result = Dali::Timer::DownCast(arg1);
58623     } catch (std::out_of_range& e) {
58624       {
58625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58626       };
58627     } catch (std::exception& e) {
58628       {
58629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58630       };
58631     } catch (Dali::DaliException e) {
58632       {
58633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58634       };
58635     } catch (...) {
58636       {
58637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58638       };
58639     }
58640   }
58641
58642   jresult = new Dali::Timer((const Dali::Timer &)result);
58643   return jresult;
58644 }
58645
58646
58647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58648   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58649
58650   arg1 = (Dali::Timer *)jarg1;
58651   {
58652     try {
58653       (arg1)->Start();
58654     } catch (std::out_of_range& e) {
58655       {
58656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58657       };
58658     } catch (std::exception& e) {
58659       {
58660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58661       };
58662     } catch (Dali::DaliException e) {
58663       {
58664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58665       };
58666     } catch (...) {
58667       {
58668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58669       };
58670     }
58671   }
58672
58673 }
58674
58675
58676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58677   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58678
58679   arg1 = (Dali::Timer *)jarg1;
58680   {
58681     try {
58682       (arg1)->Stop();
58683     } catch (std::out_of_range& e) {
58684       {
58685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58686       };
58687     } catch (std::exception& e) {
58688       {
58689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58690       };
58691     } catch (Dali::DaliException e) {
58692       {
58693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58694       };
58695     } catch (...) {
58696       {
58697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58698       };
58699     }
58700   }
58701
58702 }
58703
58704
58705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58706   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58707   unsigned int arg2 ;
58708
58709   arg1 = (Dali::Timer *)jarg1;
58710   arg2 = (unsigned int)jarg2;
58711   {
58712     try {
58713       (arg1)->SetInterval(arg2);
58714     } catch (std::out_of_range& e) {
58715       {
58716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58717       };
58718     } catch (std::exception& e) {
58719       {
58720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58721       };
58722     } catch (Dali::DaliException e) {
58723       {
58724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58725       };
58726     } catch (...) {
58727       {
58728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58729       };
58730     }
58731   }
58732
58733 }
58734
58735
58736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58737   unsigned int jresult ;
58738   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58739   unsigned int result;
58740
58741   arg1 = (Dali::Timer *)jarg1;
58742   {
58743     try {
58744       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58745     } catch (std::out_of_range& e) {
58746       {
58747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58748       };
58749     } catch (std::exception& e) {
58750       {
58751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58752       };
58753     } catch (Dali::DaliException e) {
58754       {
58755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58756       };
58757     } catch (...) {
58758       {
58759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58760       };
58761     }
58762   }
58763
58764   jresult = result;
58765   return jresult;
58766 }
58767
58768
58769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58770   unsigned int jresult ;
58771   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58772   bool result;
58773
58774   arg1 = (Dali::Timer *)jarg1;
58775   {
58776     try {
58777       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58778     } catch (std::out_of_range& e) {
58779       {
58780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58781       };
58782     } catch (std::exception& e) {
58783       {
58784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58785       };
58786     } catch (Dali::DaliException e) {
58787       {
58788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58789       };
58790     } catch (...) {
58791       {
58792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58793       };
58794     }
58795   }
58796
58797   jresult = result;
58798   return jresult;
58799 }
58800
58801
58802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58803   void * jresult ;
58804   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58805   Dali::Timer::TimerSignalType *result = 0 ;
58806
58807   arg1 = (Dali::Timer *)jarg1;
58808   {
58809     try {
58810       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58811     } catch (std::out_of_range& e) {
58812       {
58813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58814       };
58815     } catch (std::exception& e) {
58816       {
58817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58818       };
58819     } catch (Dali::DaliException e) {
58820       {
58821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58822       };
58823     } catch (...) {
58824       {
58825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58826       };
58827     }
58828   }
58829
58830   jresult = (void *)result;
58831   return jresult;
58832 }
58833
58834
58835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58836   unsigned int jresult ;
58837   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58838   bool result;
58839
58840   arg1 = (Dali::Signal< bool () > *)jarg1;
58841   {
58842     try {
58843       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58844     } catch (std::out_of_range& e) {
58845       {
58846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58847       };
58848     } catch (std::exception& e) {
58849       {
58850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58851       };
58852     } catch (Dali::DaliException e) {
58853       {
58854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58855       };
58856     } catch (...) {
58857       {
58858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58859       };
58860     }
58861   }
58862
58863   jresult = result;
58864   return jresult;
58865 }
58866
58867
58868 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58869   unsigned long jresult ;
58870   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58871   std::size_t result;
58872
58873   arg1 = (Dali::Signal< bool () > *)jarg1;
58874   {
58875     try {
58876       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58877     } catch (std::out_of_range& e) {
58878       {
58879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58880       };
58881     } catch (std::exception& e) {
58882       {
58883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58884       };
58885     } catch (Dali::DaliException e) {
58886       {
58887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58888       };
58889     } catch (...) {
58890       {
58891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58892       };
58893     }
58894   }
58895
58896   jresult = (unsigned long)result;
58897   return jresult;
58898 }
58899
58900
58901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58902   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58903   bool (*arg2)() = (bool (*)()) 0 ;
58904
58905   arg1 = (Dali::Signal< bool () > *)jarg1;
58906   arg2 = (bool (*)())jarg2;
58907   {
58908     try {
58909       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58910     } catch (std::out_of_range& e) {
58911       {
58912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58913       };
58914     } catch (std::exception& e) {
58915       {
58916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58917       };
58918     } catch (Dali::DaliException e) {
58919       {
58920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58921       };
58922     } catch (...) {
58923       {
58924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58925       };
58926     }
58927   }
58928
58929 }
58930
58931
58932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58933   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58934   bool (*arg2)() = (bool (*)()) 0 ;
58935
58936   arg1 = (Dali::Signal< bool () > *)jarg1;
58937   arg2 = (bool (*)())jarg2;
58938   {
58939     try {
58940       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58941     } catch (std::out_of_range& e) {
58942       {
58943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58944       };
58945     } catch (std::exception& e) {
58946       {
58947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58948       };
58949     } catch (Dali::DaliException e) {
58950       {
58951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58952       };
58953     } catch (...) {
58954       {
58955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58956       };
58957     }
58958   }
58959
58960 }
58961
58962
58963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58964   unsigned int jresult ;
58965   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58966   bool result;
58967
58968   arg1 = (Dali::Signal< bool () > *)jarg1;
58969   {
58970     try {
58971       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58972     } catch (std::out_of_range& e) {
58973       {
58974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58975       };
58976     } catch (std::exception& e) {
58977       {
58978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58979       };
58980     } catch (Dali::DaliException e) {
58981       {
58982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58983       };
58984     } catch (...) {
58985       {
58986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58987       };
58988     }
58989   }
58990
58991   jresult = result;
58992   return jresult;
58993 }
58994
58995
58996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
58997   void * jresult ;
58998   Dali::Signal< bool () > *result = 0 ;
58999
59000   {
59001     try {
59002       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59003     } catch (std::out_of_range& e) {
59004       {
59005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59006       };
59007     } catch (std::exception& e) {
59008       {
59009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59010       };
59011     } catch (Dali::DaliException e) {
59012       {
59013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59014       };
59015     } catch (...) {
59016       {
59017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59018       };
59019     }
59020   }
59021
59022   jresult = (void *)result;
59023   return jresult;
59024 }
59025
59026
59027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59028   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59029
59030   arg1 = (Dali::Signal< bool () > *)jarg1;
59031   {
59032     try {
59033       delete arg1;
59034     } catch (std::out_of_range& e) {
59035       {
59036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59037       };
59038     } catch (std::exception& e) {
59039       {
59040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59041       };
59042     } catch (Dali::DaliException e) {
59043       {
59044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59045       };
59046     } catch (...) {
59047       {
59048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59049       };
59050     }
59051   }
59052
59053 }
59054
59055
59056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59057   int jresult ;
59058   int result;
59059
59060   {
59061     try {
59062       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59063     } catch (std::out_of_range& e) {
59064       {
59065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59066       };
59067     } catch (std::exception& e) {
59068       {
59069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59070       };
59071     } catch (Dali::DaliException e) {
59072       {
59073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59074       };
59075     } catch (...) {
59076       {
59077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59078       };
59079     }
59080   }
59081
59082   jresult = (int)result;
59083   return jresult;
59084 }
59085
59086
59087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59088   int jresult ;
59089   int result;
59090
59091   {
59092     try {
59093       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59094     } catch (std::out_of_range& e) {
59095       {
59096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59097       };
59098     } catch (std::exception& e) {
59099       {
59100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59101       };
59102     } catch (Dali::DaliException e) {
59103       {
59104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59105       };
59106     } catch (...) {
59107       {
59108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59109       };
59110     }
59111   }
59112
59113   jresult = (int)result;
59114   return jresult;
59115 }
59116
59117
59118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59119   int jresult ;
59120   int result;
59121
59122   {
59123     try {
59124       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59125     } catch (std::out_of_range& e) {
59126       {
59127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59128       };
59129     } catch (std::exception& e) {
59130       {
59131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59132       };
59133     } catch (Dali::DaliException e) {
59134       {
59135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59136       };
59137     } catch (...) {
59138       {
59139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59140       };
59141     }
59142   }
59143
59144   jresult = (int)result;
59145   return jresult;
59146 }
59147
59148
59149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59150   int jresult ;
59151   int result;
59152
59153   {
59154     try {
59155       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59156     } catch (std::out_of_range& e) {
59157       {
59158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59159       };
59160     } catch (std::exception& e) {
59161       {
59162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59163       };
59164     } catch (Dali::DaliException e) {
59165       {
59166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59167       };
59168     } catch (...) {
59169       {
59170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59171       };
59172     }
59173   }
59174
59175   jresult = (int)result;
59176   return jresult;
59177 }
59178
59179
59180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59181   int jresult ;
59182   int result;
59183
59184   {
59185     try {
59186       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59187     } catch (std::out_of_range& e) {
59188       {
59189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59190       };
59191     } catch (std::exception& e) {
59192       {
59193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59194       };
59195     } catch (Dali::DaliException e) {
59196       {
59197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59198       };
59199     } catch (...) {
59200       {
59201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59202       };
59203     }
59204   }
59205
59206   jresult = (int)result;
59207   return jresult;
59208 }
59209
59210
59211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59212   int jresult ;
59213   int result;
59214
59215   {
59216     try {
59217       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59218     } catch (std::out_of_range& e) {
59219       {
59220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59221       };
59222     } catch (std::exception& e) {
59223       {
59224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59225       };
59226     } catch (Dali::DaliException e) {
59227       {
59228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59229       };
59230     } catch (...) {
59231       {
59232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59233       };
59234     }
59235   }
59236
59237   jresult = (int)result;
59238   return jresult;
59239 }
59240
59241
59242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59243   int jresult ;
59244   int result;
59245
59246   {
59247     try {
59248       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59249     } catch (std::out_of_range& e) {
59250       {
59251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59252       };
59253     } catch (std::exception& e) {
59254       {
59255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59256       };
59257     } catch (Dali::DaliException e) {
59258       {
59259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59260       };
59261     } catch (...) {
59262       {
59263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59264       };
59265     }
59266   }
59267
59268   jresult = (int)result;
59269   return jresult;
59270 }
59271
59272
59273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59274   int jresult ;
59275   int result;
59276
59277   {
59278     try {
59279       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59280     } catch (std::out_of_range& e) {
59281       {
59282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59283       };
59284     } catch (std::exception& e) {
59285       {
59286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59287       };
59288     } catch (Dali::DaliException e) {
59289       {
59290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59291       };
59292     } catch (...) {
59293       {
59294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59295       };
59296     }
59297   }
59298
59299   jresult = (int)result;
59300   return jresult;
59301 }
59302
59303
59304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59305   int jresult ;
59306   int result;
59307
59308   {
59309     try {
59310       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59311     } catch (std::out_of_range& e) {
59312       {
59313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59314       };
59315     } catch (std::exception& e) {
59316       {
59317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59318       };
59319     } catch (Dali::DaliException e) {
59320       {
59321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59322       };
59323     } catch (...) {
59324       {
59325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59326       };
59327     }
59328   }
59329
59330   jresult = (int)result;
59331   return jresult;
59332 }
59333
59334
59335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59336   int jresult ;
59337   int result;
59338
59339   {
59340     try {
59341       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59342     } catch (std::out_of_range& e) {
59343       {
59344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59345       };
59346     } catch (std::exception& e) {
59347       {
59348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59349       };
59350     } catch (Dali::DaliException e) {
59351       {
59352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59353       };
59354     } catch (...) {
59355       {
59356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59357       };
59358     }
59359   }
59360
59361   jresult = (int)result;
59362   return jresult;
59363 }
59364
59365
59366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59367   int jresult ;
59368   int result;
59369
59370   {
59371     try {
59372       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59373     } catch (std::out_of_range& e) {
59374       {
59375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59376       };
59377     } catch (std::exception& e) {
59378       {
59379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59380       };
59381     } catch (Dali::DaliException e) {
59382       {
59383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59384       };
59385     } catch (...) {
59386       {
59387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59388       };
59389     }
59390   }
59391
59392   jresult = (int)result;
59393   return jresult;
59394 }
59395
59396
59397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59398   int jresult ;
59399   int result;
59400
59401   {
59402     try {
59403       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59404     } catch (std::out_of_range& e) {
59405       {
59406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59407       };
59408     } catch (std::exception& e) {
59409       {
59410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59411       };
59412     } catch (Dali::DaliException e) {
59413       {
59414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59415       };
59416     } catch (...) {
59417       {
59418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59419       };
59420     }
59421   }
59422
59423   jresult = (int)result;
59424   return jresult;
59425 }
59426
59427
59428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59429   int jresult ;
59430   int result;
59431
59432   {
59433     try {
59434       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59435     } catch (std::out_of_range& e) {
59436       {
59437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59438       };
59439     } catch (std::exception& e) {
59440       {
59441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59442       };
59443     } catch (Dali::DaliException e) {
59444       {
59445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59450       };
59451     }
59452   }
59453
59454   jresult = (int)result;
59455   return jresult;
59456 }
59457
59458
59459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59460   int jresult ;
59461   int result;
59462
59463   {
59464     try {
59465       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59466     } catch (std::out_of_range& e) {
59467       {
59468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59469       };
59470     } catch (std::exception& e) {
59471       {
59472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59473       };
59474     } catch (Dali::DaliException e) {
59475       {
59476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59477       };
59478     } catch (...) {
59479       {
59480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59481       };
59482     }
59483   }
59484
59485   jresult = (int)result;
59486   return jresult;
59487 }
59488
59489
59490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59491   int jresult ;
59492   int result;
59493
59494   {
59495     try {
59496       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59497     } catch (std::out_of_range& e) {
59498       {
59499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59500       };
59501     } catch (std::exception& e) {
59502       {
59503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59504       };
59505     } catch (Dali::DaliException e) {
59506       {
59507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59508       };
59509     } catch (...) {
59510       {
59511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59512       };
59513     }
59514   }
59515
59516   jresult = (int)result;
59517   return jresult;
59518 }
59519
59520
59521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59522   int jresult ;
59523   int result;
59524
59525   {
59526     try {
59527       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59528     } catch (std::out_of_range& e) {
59529       {
59530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59531       };
59532     } catch (std::exception& e) {
59533       {
59534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59535       };
59536     } catch (Dali::DaliException e) {
59537       {
59538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59539       };
59540     } catch (...) {
59541       {
59542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59543       };
59544     }
59545   }
59546
59547   jresult = (int)result;
59548   return jresult;
59549 }
59550
59551
59552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59553   int jresult ;
59554   int result;
59555
59556   {
59557     try {
59558       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59559     } catch (std::out_of_range& e) {
59560       {
59561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59562       };
59563     } catch (std::exception& e) {
59564       {
59565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59566       };
59567     } catch (Dali::DaliException e) {
59568       {
59569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59570       };
59571     } catch (...) {
59572       {
59573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59574       };
59575     }
59576   }
59577
59578   jresult = (int)result;
59579   return jresult;
59580 }
59581
59582
59583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59584   int jresult ;
59585   int result;
59586
59587   {
59588     try {
59589       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59590     } catch (std::out_of_range& e) {
59591       {
59592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59593       };
59594     } catch (std::exception& e) {
59595       {
59596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59597       };
59598     } catch (Dali::DaliException e) {
59599       {
59600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59601       };
59602     } catch (...) {
59603       {
59604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59605       };
59606     }
59607   }
59608
59609   jresult = (int)result;
59610   return jresult;
59611 }
59612
59613
59614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59615   int jresult ;
59616   int result;
59617
59618   {
59619     try {
59620       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59621     } catch (std::out_of_range& e) {
59622       {
59623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59624       };
59625     } catch (std::exception& e) {
59626       {
59627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59628       };
59629     } catch (Dali::DaliException e) {
59630       {
59631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59632       };
59633     } catch (...) {
59634       {
59635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59636       };
59637     }
59638   }
59639
59640   jresult = (int)result;
59641   return jresult;
59642 }
59643
59644
59645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59646   int jresult ;
59647   int result;
59648
59649   {
59650     try {
59651       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59652     } catch (std::out_of_range& e) {
59653       {
59654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59655       };
59656     } catch (std::exception& e) {
59657       {
59658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59659       };
59660     } catch (Dali::DaliException e) {
59661       {
59662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59663       };
59664     } catch (...) {
59665       {
59666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59667       };
59668     }
59669   }
59670
59671   jresult = (int)result;
59672   return jresult;
59673 }
59674
59675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59676   int jresult ;
59677   int result;
59678
59679   {
59680     try {
59681       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59682     } catch (std::out_of_range& e) {
59683       {
59684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59685       };
59686     } catch (std::exception& e) {
59687       {
59688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59689       };
59690     } catch (Dali::DaliException e) {
59691       {
59692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59693       };
59694     } catch (...) {
59695       {
59696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59697       };
59698     }
59699   }
59700
59701   jresult = (int)result;
59702   return jresult;
59703 }
59704
59705
59706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59707   int jresult ;
59708   int result;
59709   {
59710     try
59711     {
59712       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59713     } catch (std::out_of_range& e) {
59714       {
59715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59716       };
59717     } catch (std::exception& e) {
59718       {
59719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59720       };
59721     } catch (Dali::DaliException e) {
59722       {
59723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59724       };
59725     } catch (...) {
59726       {
59727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59728       };
59729     }
59730   }
59731
59732   jresult = (int)result;
59733   return jresult;
59734 }
59735
59736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59737   int jresult ;
59738   int result;
59739   {
59740     try
59741     {
59742       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59743     } catch (std::out_of_range& e) {
59744       {
59745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59746       };
59747     } catch (std::exception& e) {
59748       {
59749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59750       };
59751     } catch (Dali::DaliException e) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59754       };
59755     } catch (...) {
59756       {
59757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59758       };
59759     }
59760   }
59761
59762   jresult = (int)result;
59763   return jresult;
59764 }
59765
59766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59767   int jresult ;
59768   int result;
59769   {
59770     try
59771     {
59772       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59773     } catch (std::out_of_range& e) {
59774       {
59775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59776       };
59777     } catch (std::exception& e) {
59778       {
59779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59780       };
59781     } catch (Dali::DaliException e) {
59782       {
59783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59784       };
59785     } catch (...) {
59786       {
59787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59788       };
59789     }
59790   }
59791
59792   jresult = (int)result;
59793   return jresult;
59794 }
59795
59796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59797   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59798 }
59799
59800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59801   int jresult ;
59802   int result;
59803   {
59804     try
59805     {
59806       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59807     } catch (std::out_of_range& e) {
59808       {
59809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59810       };
59811     } catch (std::exception& e) {
59812       {
59813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59814       };
59815     } catch (Dali::DaliException e) {
59816       {
59817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59818       };
59819     } catch (...) {
59820       {
59821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59822       };
59823     }
59824   }
59825
59826   jresult = (int)result;
59827   return jresult;
59828 }
59829
59830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59831   int jresult ;
59832   int result;
59833   {
59834     try
59835     {
59836       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59837     } catch (std::out_of_range& e) {
59838       {
59839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59840       };
59841     } catch (std::exception& e) {
59842       {
59843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59844       };
59845     } catch (Dali::DaliException e) {
59846       {
59847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59848       };
59849     } catch (...) {
59850       {
59851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59852       };
59853     }
59854   }
59855
59856   jresult = (int)result;
59857   return jresult;
59858 }
59859
59860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59861   int jresult ;
59862   int result;
59863
59864   {
59865     try {
59866       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59867     } catch (std::out_of_range& e) {
59868       {
59869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59870       };
59871     } catch (std::exception& e) {
59872       {
59873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59874       };
59875     } catch (Dali::DaliException e) {
59876       {
59877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59878       };
59879     } catch (...) {
59880       {
59881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59882       };
59883     }
59884   }
59885
59886   jresult = (int)result;
59887   return jresult;
59888 }
59889
59890
59891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59892   int jresult ;
59893   int result;
59894
59895   {
59896     try {
59897       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59898     } catch (std::out_of_range& e) {
59899       {
59900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59901       };
59902     } catch (std::exception& e) {
59903       {
59904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59905       };
59906     } catch (Dali::DaliException e) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59909       };
59910     } catch (...) {
59911       {
59912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59913       };
59914     }
59915   }
59916
59917   jresult = (int)result;
59918   return jresult;
59919 }
59920
59921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59922   int jresult ;
59923   int result;
59924   {
59925     try
59926     {
59927       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59928     } catch (std::out_of_range& e) {
59929       {
59930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59931       };
59932     } catch (std::exception& e) {
59933       {
59934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59935       };
59936     } catch (...) {
59937       {
59938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59939       };
59940     }
59941   }
59942   jresult = (int)result;
59943   return jresult;
59944 }
59945
59946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59947   int jresult ;
59948   int result;
59949   {
59950     try
59951     {
59952       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59953     } catch (std::out_of_range& e) {
59954       {
59955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59956       };
59957     } catch (std::exception& e) {
59958       {
59959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59960       };
59961     } catch (...) {
59962       {
59963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59964       };
59965     }
59966   }
59967   jresult = (int)result;
59968   return jresult;
59969 }
59970
59971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59972   int jresult ;
59973   int result;
59974   {
59975     try
59976     {
59977       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59978     } catch (std::out_of_range& e) {
59979       {
59980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59981       };
59982     } catch (std::exception& e) {
59983       {
59984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59985       };
59986     } catch (...) {
59987       {
59988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59989       };
59990     }
59991   }
59992   jresult = (int)result;
59993   return jresult;
59994 }
59995
59996
59997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
59998   int jresult ;
59999   int result;
60000   {
60001     try
60002     {
60003       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60004     } catch (std::out_of_range& e) {
60005       {
60006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (std::exception& e) {
60009       {
60010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60011       };
60012     } catch (...) {
60013       {
60014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60015       };
60016     }
60017   }
60018   jresult = (int)result;
60019   return jresult;
60020 }
60021
60022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60023   int jresult ;
60024   int result;
60025   {
60026     try
60027     {
60028       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60029     } catch (std::out_of_range& e) {
60030       {
60031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60032       };
60033     } catch (std::exception& e) {
60034       {
60035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60036       };
60037     } catch (...) {
60038       {
60039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60040       };
60041     }
60042   }
60043   jresult = (int)result;
60044   return jresult;
60045 }
60046
60047
60048
60049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60050   int jresult ;
60051   int result;
60052
60053   {
60054     try {
60055       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60056     } catch (std::out_of_range& e) {
60057       {
60058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60059       };
60060     } catch (std::exception& e) {
60061       {
60062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60063       };
60064     } catch (Dali::DaliException e) {
60065       {
60066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60067       };
60068     } catch (...) {
60069       {
60070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60071       };
60072     }
60073   }
60074
60075   jresult = (int)result;
60076   return jresult;
60077 }
60078
60079
60080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60081   int jresult ;
60082   int result;
60083
60084   {
60085     try {
60086       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60087     } catch (std::out_of_range& e) {
60088       {
60089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60090       };
60091     } catch (std::exception& e) {
60092       {
60093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60094       };
60095     } catch (Dali::DaliException e) {
60096       {
60097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60098       };
60099     } catch (...) {
60100       {
60101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60102       };
60103     }
60104   }
60105
60106   jresult = (int)result;
60107   return jresult;
60108 }
60109
60110
60111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60112   int jresult ;
60113   int result;
60114
60115   {
60116     try {
60117       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60118     } catch (std::out_of_range& e) {
60119       {
60120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60121       };
60122     } catch (std::exception& e) {
60123       {
60124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60125       };
60126     } catch (Dali::DaliException e) {
60127       {
60128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60129       };
60130     } catch (...) {
60131       {
60132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60133       };
60134     }
60135   }
60136
60137   jresult = (int)result;
60138   return jresult;
60139 }
60140
60141
60142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60143   int jresult ;
60144   int result;
60145
60146   {
60147     try {
60148       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60149     } catch (std::out_of_range& e) {
60150       {
60151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60152       };
60153     } catch (std::exception& e) {
60154       {
60155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60156       };
60157     } catch (Dali::DaliException e) {
60158       {
60159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60160       };
60161     } catch (...) {
60162       {
60163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60164       };
60165     }
60166   }
60167
60168   jresult = (int)result;
60169   return jresult;
60170 }
60171
60172
60173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60174   int jresult ;
60175   int result;
60176
60177   {
60178     try {
60179       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60180     } catch (std::out_of_range& e) {
60181       {
60182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60183       };
60184     } catch (std::exception& e) {
60185       {
60186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60187       };
60188     } catch (Dali::DaliException e) {
60189       {
60190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60191       };
60192     } catch (...) {
60193       {
60194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60195       };
60196     }
60197   }
60198
60199   jresult = (int)result;
60200   return jresult;
60201 }
60202
60203
60204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60205   int jresult ;
60206   int result;
60207
60208   {
60209     try {
60210       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60211     } catch (std::out_of_range& e) {
60212       {
60213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (std::exception& e) {
60216       {
60217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60218       };
60219     } catch (Dali::DaliException e) {
60220       {
60221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60222       };
60223     } catch (...) {
60224       {
60225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60226       };
60227     }
60228   }
60229
60230   jresult = (int)result;
60231   return jresult;
60232 }
60233
60234
60235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60236   int jresult ;
60237   int result;
60238
60239   {
60240     try {
60241       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60242     } catch (std::out_of_range& e) {
60243       {
60244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60245       };
60246     } catch (std::exception& e) {
60247       {
60248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60249       };
60250     } catch (Dali::DaliException e) {
60251       {
60252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60253       };
60254     } catch (...) {
60255       {
60256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60257       };
60258     }
60259   }
60260
60261   jresult = (int)result;
60262   return jresult;
60263 }
60264
60265 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60266   int jresult ;
60267   int result;
60268
60269   {
60270     try {
60271       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60272     } catch (std::out_of_range& e) {
60273       {
60274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60275       };
60276     } catch (std::exception& e) {
60277       {
60278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60279       };
60280     } catch (...) {
60281       {
60282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60283       };
60284     }
60285   }
60286   jresult = (int)result;
60287   return jresult;
60288 }
60289
60290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60291   int jresult ;
60292   int result;
60293
60294   {
60295     try {
60296       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60297     } catch (std::out_of_range& e) {
60298       {
60299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60300       };
60301     } catch (std::exception& e) {
60302       {
60303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60304       };
60305     } catch (Dali::DaliException e) {
60306       {
60307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60308       };
60309     } catch (...) {
60310       {
60311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60312       };
60313     }
60314   }
60315
60316   jresult = (int)result;
60317   return jresult;
60318 }
60319
60320
60321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60322   int jresult ;
60323   int result;
60324
60325   {
60326     try {
60327       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60328     } catch (std::out_of_range& e) {
60329       {
60330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60331       };
60332     } catch (std::exception& e) {
60333       {
60334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60335       };
60336     } catch (Dali::DaliException e) {
60337       {
60338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60339       };
60340     } catch (...) {
60341       {
60342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60343       };
60344     }
60345   }
60346
60347   jresult = (int)result;
60348   return jresult;
60349 }
60350
60351
60352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60353   int jresult ;
60354   int result;
60355
60356   {
60357     try {
60358       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60359     } catch (std::out_of_range& e) {
60360       {
60361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60362       };
60363     } catch (std::exception& e) {
60364       {
60365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60366       };
60367     } catch (Dali::DaliException e) {
60368       {
60369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60370       };
60371     } catch (...) {
60372       {
60373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60374       };
60375     }
60376   }
60377
60378   jresult = (int)result;
60379   return jresult;
60380 }
60381
60382
60383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60384   int jresult ;
60385   int result;
60386
60387   {
60388     try {
60389       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60390     } catch (std::out_of_range& e) {
60391       {
60392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60393       };
60394     } catch (std::exception& e) {
60395       {
60396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60397       };
60398     } catch (Dali::DaliException e) {
60399       {
60400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60401       };
60402     } catch (...) {
60403       {
60404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60405       };
60406     }
60407   }
60408
60409   jresult = (int)result;
60410   return jresult;
60411 }
60412
60413
60414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60415   int jresult ;
60416   int result;
60417
60418   {
60419     try {
60420       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60421     } catch (std::out_of_range& e) {
60422       {
60423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60424       };
60425     } catch (std::exception& e) {
60426       {
60427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60428       };
60429     } catch (Dali::DaliException e) {
60430       {
60431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60432       };
60433     } catch (...) {
60434       {
60435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60436       };
60437     }
60438   }
60439
60440   jresult = (int)result;
60441   return jresult;
60442 }
60443
60444
60445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60446   int jresult ;
60447   int result;
60448
60449   {
60450     try {
60451       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60452     } catch (std::out_of_range& e) {
60453       {
60454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60455       };
60456     } catch (std::exception& e) {
60457       {
60458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60459       };
60460     } catch (Dali::DaliException e) {
60461       {
60462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60463       };
60464     } catch (...) {
60465       {
60466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60467       };
60468     }
60469   }
60470
60471   jresult = (int)result;
60472   return jresult;
60473 }
60474
60475
60476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60477   int jresult ;
60478   int result;
60479
60480   {
60481     try {
60482       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60483     } catch (std::out_of_range& e) {
60484       {
60485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60486       };
60487     } catch (std::exception& e) {
60488       {
60489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60490       };
60491     } catch (Dali::DaliException e) {
60492       {
60493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60494       };
60495     } catch (...) {
60496       {
60497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60498       };
60499     }
60500   }
60501
60502   jresult = (int)result;
60503   return jresult;
60504 }
60505
60506
60507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60508   int jresult ;
60509   int result;
60510
60511   {
60512     try {
60513       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60514     } catch (std::out_of_range& e) {
60515       {
60516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60517       };
60518     } catch (std::exception& e) {
60519       {
60520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60521       };
60522     } catch (Dali::DaliException e) {
60523       {
60524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60525       };
60526     } catch (...) {
60527       {
60528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60529       };
60530     }
60531   }
60532
60533   jresult = (int)result;
60534   return jresult;
60535 }
60536
60537
60538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60539   int jresult ;
60540   int result;
60541
60542   {
60543     try {
60544       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60545     } catch (std::out_of_range& e) {
60546       {
60547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60548       };
60549     } catch (std::exception& e) {
60550       {
60551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60552       };
60553     } catch (Dali::DaliException e) {
60554       {
60555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60556       };
60557     } catch (...) {
60558       {
60559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60560       };
60561     }
60562   }
60563
60564   jresult = (int)result;
60565   return jresult;
60566 }
60567
60568
60569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60570   int jresult ;
60571   int result;
60572
60573   {
60574     try {
60575       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60576     } catch (std::out_of_range& e) {
60577       {
60578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60579       };
60580     } catch (std::exception& e) {
60581       {
60582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60583       };
60584     } catch (Dali::DaliException e) {
60585       {
60586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60587       };
60588     } catch (...) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60591       };
60592     }
60593   }
60594
60595   jresult = (int)result;
60596   return jresult;
60597 }
60598
60599
60600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60601   int jresult ;
60602   int result;
60603
60604   {
60605     try {
60606       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60607     } catch (std::out_of_range& e) {
60608       {
60609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60610       };
60611     } catch (std::exception& e) {
60612       {
60613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60614       };
60615     } catch (Dali::DaliException e) {
60616       {
60617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60618       };
60619     } catch (...) {
60620       {
60621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60622       };
60623     }
60624   }
60625
60626   jresult = (int)result;
60627   return jresult;
60628 }
60629
60630
60631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60632   int jresult ;
60633   int result;
60634
60635   {
60636     try {
60637       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60638     } catch (std::out_of_range& e) {
60639       {
60640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60641       };
60642     } catch (std::exception& e) {
60643       {
60644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60645       };
60646     } catch (Dali::DaliException e) {
60647       {
60648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60649       };
60650     } catch (...) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60653       };
60654     }
60655   }
60656
60657   jresult = (int)result;
60658   return jresult;
60659 }
60660
60661
60662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60663   int jresult ;
60664   int result;
60665
60666   {
60667     try {
60668       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60669     } catch (std::out_of_range& e) {
60670       {
60671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60672       };
60673     } catch (std::exception& e) {
60674       {
60675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60676       };
60677     } catch (Dali::DaliException e) {
60678       {
60679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60680       };
60681     } catch (...) {
60682       {
60683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60684       };
60685     }
60686   }
60687
60688   jresult = (int)result;
60689   return jresult;
60690 }
60691
60692
60693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60694   int jresult ;
60695   int result;
60696
60697   {
60698     try {
60699       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60700     } catch (std::out_of_range& e) {
60701       {
60702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60703       };
60704     } catch (std::exception& e) {
60705       {
60706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60707       };
60708     } catch (Dali::DaliException e) {
60709       {
60710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60711       };
60712     } catch (...) {
60713       {
60714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60715       };
60716     }
60717   }
60718
60719   jresult = (int)result;
60720   return jresult;
60721 }
60722
60723
60724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60725   int jresult ;
60726   int result;
60727
60728   {
60729     try {
60730       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60731     } catch (std::out_of_range& e) {
60732       {
60733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60734       };
60735     } catch (std::exception& e) {
60736       {
60737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60738       };
60739     } catch (Dali::DaliException e) {
60740       {
60741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60742       };
60743     } catch (...) {
60744       {
60745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60746       };
60747     }
60748   }
60749
60750   jresult = (int)result;
60751   return jresult;
60752 }
60753
60754
60755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60756   int jresult ;
60757   int result;
60758
60759   {
60760     try {
60761       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60762     } catch (std::out_of_range& e) {
60763       {
60764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60765       };
60766     } catch (std::exception& e) {
60767       {
60768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60769       };
60770     } catch (Dali::DaliException e) {
60771       {
60772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60773       };
60774     } catch (...) {
60775       {
60776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60777       };
60778     }
60779   }
60780
60781   jresult = (int)result;
60782   return jresult;
60783 }
60784
60785
60786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60787   int jresult ;
60788   int result;
60789
60790   {
60791     try {
60792       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60793     } catch (std::out_of_range& e) {
60794       {
60795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60796       };
60797     } catch (std::exception& e) {
60798       {
60799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60800       };
60801     } catch (Dali::DaliException e) {
60802       {
60803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60804       };
60805     } catch (...) {
60806       {
60807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60808       };
60809     }
60810   }
60811
60812   jresult = (int)result;
60813   return jresult;
60814 }
60815
60816
60817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60818   int jresult ;
60819   int result;
60820
60821   {
60822     try {
60823       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60824     } catch (std::out_of_range& e) {
60825       {
60826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60827       };
60828     } catch (std::exception& e) {
60829       {
60830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60831       };
60832     } catch (Dali::DaliException e) {
60833       {
60834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60835       };
60836     } catch (...) {
60837       {
60838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60839       };
60840     }
60841   }
60842
60843   jresult = (int)result;
60844   return jresult;
60845 }
60846
60847
60848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60849   int jresult ;
60850   int result;
60851
60852   {
60853     try {
60854       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60855     } catch (std::out_of_range& e) {
60856       {
60857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60858       };
60859     } catch (std::exception& e) {
60860       {
60861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60862       };
60863     } catch (Dali::DaliException e) {
60864       {
60865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60866       };
60867     } catch (...) {
60868       {
60869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60870       };
60871     }
60872   }
60873
60874   jresult = (int)result;
60875   return jresult;
60876 }
60877
60878
60879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60880   int jresult ;
60881   int result;
60882
60883   {
60884     try {
60885       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60886     } catch (std::out_of_range& e) {
60887       {
60888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60889       };
60890     } catch (std::exception& e) {
60891       {
60892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60893       };
60894     } catch (Dali::DaliException e) {
60895       {
60896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60897       };
60898     } catch (...) {
60899       {
60900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60901       };
60902     }
60903   }
60904
60905   jresult = (int)result;
60906   return jresult;
60907 }
60908
60909
60910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60911   int jresult ;
60912   int result;
60913
60914   {
60915     try {
60916       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60917     } catch (std::out_of_range& e) {
60918       {
60919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60920       };
60921     } catch (std::exception& e) {
60922       {
60923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60924       };
60925     } catch (Dali::DaliException e) {
60926       {
60927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60928       };
60929     } catch (...) {
60930       {
60931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60932       };
60933     }
60934   }
60935
60936   jresult = (int)result;
60937   return jresult;
60938 }
60939
60940
60941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60942   int jresult ;
60943   int result;
60944
60945   {
60946     try {
60947       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60948     } catch (std::out_of_range& e) {
60949       {
60950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60951       };
60952     } catch (std::exception& e) {
60953       {
60954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60955       };
60956     } catch (Dali::DaliException e) {
60957       {
60958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60959       };
60960     } catch (...) {
60961       {
60962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60963       };
60964     }
60965   }
60966
60967   jresult = (int)result;
60968   return jresult;
60969 }
60970
60971
60972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60973   int jresult ;
60974   int result;
60975
60976   {
60977     try {
60978       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60979     } catch (std::out_of_range& e) {
60980       {
60981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60982       };
60983     } catch (std::exception& e) {
60984       {
60985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60986       };
60987     } catch (Dali::DaliException e) {
60988       {
60989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60990       };
60991     } catch (...) {
60992       {
60993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60994       };
60995     }
60996   }
60997
60998   jresult = (int)result;
60999   return jresult;
61000 }
61001
61002
61003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61004   int jresult ;
61005   int result;
61006
61007   {
61008     try {
61009       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61010     } catch (std::out_of_range& e) {
61011       {
61012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61013       };
61014     } catch (std::exception& e) {
61015       {
61016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61017       };
61018     } catch (Dali::DaliException e) {
61019       {
61020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61021       };
61022     } catch (...) {
61023       {
61024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61025       };
61026     }
61027   }
61028
61029   jresult = (int)result;
61030   return jresult;
61031 }
61032
61033
61034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61035   int jresult ;
61036   int result;
61037
61038   {
61039     try {
61040       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61041     } catch (std::out_of_range& e) {
61042       {
61043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61044       };
61045     } catch (std::exception& e) {
61046       {
61047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61048       };
61049     } catch (Dali::DaliException e) {
61050       {
61051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61052       };
61053     } catch (...) {
61054       {
61055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61056       };
61057     }
61058   }
61059
61060   jresult = (int)result;
61061   return jresult;
61062 }
61063
61064
61065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61066   int jresult ;
61067   int result;
61068
61069   {
61070     try {
61071       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61072     } catch (std::out_of_range& e) {
61073       {
61074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61075       };
61076     } catch (std::exception& e) {
61077       {
61078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61079       };
61080     } catch (Dali::DaliException e) {
61081       {
61082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61083       };
61084     } catch (...) {
61085       {
61086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61087       };
61088     }
61089   }
61090
61091   jresult = (int)result;
61092   return jresult;
61093 }
61094
61095
61096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61097   int jresult ;
61098   int result;
61099
61100   {
61101     try {
61102       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61103     } catch (std::out_of_range& e) {
61104       {
61105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61106       };
61107     } catch (std::exception& e) {
61108       {
61109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61110       };
61111     } catch (Dali::DaliException e) {
61112       {
61113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61114       };
61115     } catch (...) {
61116       {
61117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61118       };
61119     }
61120   }
61121
61122   jresult = (int)result;
61123   return jresult;
61124 }
61125
61126
61127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61128   int jresult ;
61129   int result;
61130
61131   {
61132     try {
61133       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61134     } catch (std::out_of_range& e) {
61135       {
61136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61137       };
61138     } catch (std::exception& e) {
61139       {
61140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61141       };
61142     } catch (Dali::DaliException e) {
61143       {
61144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61145       };
61146     } catch (...) {
61147       {
61148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61149       };
61150     }
61151   }
61152
61153   jresult = (int)result;
61154   return jresult;
61155 }
61156
61157
61158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61159   void * jresult ;
61160   Dali::Toolkit::Builder *result = 0 ;
61161
61162   {
61163     try {
61164       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61165     } catch (std::out_of_range& e) {
61166       {
61167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61168       };
61169     } catch (std::exception& e) {
61170       {
61171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61172       };
61173     } catch (Dali::DaliException e) {
61174       {
61175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61176       };
61177     } catch (...) {
61178       {
61179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61180       };
61181     }
61182   }
61183
61184   jresult = (void *)result;
61185   return jresult;
61186 }
61187
61188
61189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61190   void * jresult ;
61191   Dali::Toolkit::Builder result;
61192
61193   {
61194     try {
61195       result = Dali::Toolkit::Builder::New();
61196     } catch (std::out_of_range& e) {
61197       {
61198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61199       };
61200     } catch (std::exception& e) {
61201       {
61202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61203       };
61204     } catch (Dali::DaliException e) {
61205       {
61206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61207       };
61208     } catch (...) {
61209       {
61210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61211       };
61212     }
61213   }
61214
61215   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61216   return jresult;
61217 }
61218
61219
61220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61221   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61222
61223   arg1 = (Dali::Toolkit::Builder *)jarg1;
61224   {
61225     try {
61226       delete arg1;
61227     } catch (std::out_of_range& e) {
61228       {
61229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61230       };
61231     } catch (std::exception& e) {
61232       {
61233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61234       };
61235     } catch (Dali::DaliException e) {
61236       {
61237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61238       };
61239     } catch (...) {
61240       {
61241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61242       };
61243     }
61244   }
61245
61246 }
61247
61248
61249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61250   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61251   std::string *arg2 = 0 ;
61252   Dali::Toolkit::Builder::UIFormat arg3 ;
61253
61254   arg1 = (Dali::Toolkit::Builder *)jarg1;
61255   if (!jarg2) {
61256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61257     return ;
61258   }
61259   std::string arg2_str(jarg2);
61260   arg2 = &arg2_str;
61261   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61262   {
61263     try {
61264       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61265     } catch (std::out_of_range& e) {
61266       {
61267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61268       };
61269     } catch (std::exception& e) {
61270       {
61271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61272       };
61273     } catch (Dali::DaliException e) {
61274       {
61275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61276       };
61277     } catch (...) {
61278       {
61279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61280       };
61281     }
61282   }
61283
61284
61285   //argout typemap for const std::string&
61286
61287 }
61288
61289
61290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61292   std::string *arg2 = 0 ;
61293
61294   arg1 = (Dali::Toolkit::Builder *)jarg1;
61295   if (!jarg2) {
61296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61297     return ;
61298   }
61299   std::string arg2_str(jarg2);
61300   arg2 = &arg2_str;
61301   {
61302     try {
61303       (arg1)->LoadFromString((std::string const &)*arg2);
61304     } catch (std::out_of_range& e) {
61305       {
61306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61307       };
61308     } catch (std::exception& e) {
61309       {
61310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61311       };
61312     } catch (Dali::DaliException e) {
61313       {
61314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61315       };
61316     } catch (...) {
61317       {
61318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61319       };
61320     }
61321   }
61322
61323
61324   //argout typemap for const std::string&
61325
61326 }
61327
61328
61329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61330   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61331   Dali::Property::Map *arg2 = 0 ;
61332
61333   arg1 = (Dali::Toolkit::Builder *)jarg1;
61334   arg2 = (Dali::Property::Map *)jarg2;
61335   if (!arg2) {
61336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61337     return ;
61338   }
61339   {
61340     try {
61341       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61342     } catch (std::out_of_range& e) {
61343       {
61344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61345       };
61346     } catch (std::exception& e) {
61347       {
61348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61349       };
61350     } catch (Dali::DaliException e) {
61351       {
61352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61353       };
61354     } catch (...) {
61355       {
61356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61357       };
61358     }
61359   }
61360
61361 }
61362
61363
61364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61365   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61366   std::string *arg2 = 0 ;
61367   Dali::Property::Value *arg3 = 0 ;
61368
61369   arg1 = (Dali::Toolkit::Builder *)jarg1;
61370   if (!jarg2) {
61371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61372     return ;
61373   }
61374   std::string arg2_str(jarg2);
61375   arg2 = &arg2_str;
61376   arg3 = (Dali::Property::Value *)jarg3;
61377   if (!arg3) {
61378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61379     return ;
61380   }
61381   {
61382     try {
61383       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61384     } catch (std::out_of_range& e) {
61385       {
61386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61387       };
61388     } catch (std::exception& e) {
61389       {
61390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61391       };
61392     } catch (Dali::DaliException e) {
61393       {
61394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61395       };
61396     } catch (...) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61399       };
61400     }
61401   }
61402
61403
61404   //argout typemap for const std::string&
61405
61406 }
61407
61408
61409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61410   void * jresult ;
61411   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61412   Dali::Property::Map *result = 0 ;
61413
61414   arg1 = (Dali::Toolkit::Builder *)jarg1;
61415   {
61416     try {
61417       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61418     } catch (std::out_of_range& e) {
61419       {
61420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61421       };
61422     } catch (std::exception& e) {
61423       {
61424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61425       };
61426     } catch (Dali::DaliException e) {
61427       {
61428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61429       };
61430     } catch (...) {
61431       {
61432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61433       };
61434     }
61435   }
61436
61437   jresult = (void *)result;
61438   return jresult;
61439 }
61440
61441
61442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61443   void * jresult ;
61444   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61445   std::string *arg2 = 0 ;
61446   Dali::Property::Value *result = 0 ;
61447
61448   arg1 = (Dali::Toolkit::Builder *)jarg1;
61449   if (!jarg2) {
61450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61451     return 0;
61452   }
61453   std::string arg2_str(jarg2);
61454   arg2 = &arg2_str;
61455   {
61456     try {
61457       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61458     } catch (std::out_of_range& e) {
61459       {
61460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61461       };
61462     } catch (std::exception& e) {
61463       {
61464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61465       };
61466     } catch (Dali::DaliException e) {
61467       {
61468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61469       };
61470     } catch (...) {
61471       {
61472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61473       };
61474     }
61475   }
61476
61477   jresult = (void *)result;
61478
61479   //argout typemap for const std::string&
61480
61481   return jresult;
61482 }
61483
61484
61485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61486   void * jresult ;
61487   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61488   std::string *arg2 = 0 ;
61489   Dali::Animation result;
61490
61491   arg1 = (Dali::Toolkit::Builder *)jarg1;
61492   if (!jarg2) {
61493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61494     return 0;
61495   }
61496   std::string arg2_str(jarg2);
61497   arg2 = &arg2_str;
61498   {
61499     try {
61500       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61501     } catch (std::out_of_range& e) {
61502       {
61503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61504       };
61505     } catch (std::exception& e) {
61506       {
61507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61508       };
61509     } catch (Dali::DaliException e) {
61510       {
61511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61512       };
61513     } catch (...) {
61514       {
61515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61516       };
61517     }
61518   }
61519
61520   jresult = new Dali::Animation((const Dali::Animation &)result);
61521
61522   //argout typemap for const std::string&
61523
61524   return jresult;
61525 }
61526
61527
61528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61529   void * jresult ;
61530   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61531   std::string *arg2 = 0 ;
61532   Dali::Property::Map *arg3 = 0 ;
61533   Dali::Animation result;
61534
61535   arg1 = (Dali::Toolkit::Builder *)jarg1;
61536   if (!jarg2) {
61537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61538     return 0;
61539   }
61540   std::string arg2_str(jarg2);
61541   arg2 = &arg2_str;
61542   arg3 = (Dali::Property::Map *)jarg3;
61543   if (!arg3) {
61544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61545     return 0;
61546   }
61547   {
61548     try {
61549       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61550     } catch (std::out_of_range& e) {
61551       {
61552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61553       };
61554     } catch (std::exception& e) {
61555       {
61556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61557       };
61558     } catch (Dali::DaliException e) {
61559       {
61560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61561       };
61562     } catch (...) {
61563       {
61564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61565       };
61566     }
61567   }
61568
61569   jresult = new Dali::Animation((const Dali::Animation &)result);
61570
61571   //argout typemap for const std::string&
61572
61573   return jresult;
61574 }
61575
61576
61577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61578   void * jresult ;
61579   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61580   std::string *arg2 = 0 ;
61581   Dali::Actor arg3 ;
61582   Dali::Actor *argp3 ;
61583   Dali::Animation result;
61584
61585   arg1 = (Dali::Toolkit::Builder *)jarg1;
61586   if (!jarg2) {
61587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61588     return 0;
61589   }
61590   std::string arg2_str(jarg2);
61591   arg2 = &arg2_str;
61592   argp3 = (Dali::Actor *)jarg3;
61593   if (!argp3) {
61594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61595     return 0;
61596   }
61597   arg3 = *argp3;
61598   {
61599     try {
61600       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61601     } catch (std::out_of_range& e) {
61602       {
61603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61604       };
61605     } catch (std::exception& e) {
61606       {
61607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61608       };
61609     } catch (Dali::DaliException e) {
61610       {
61611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61612       };
61613     } catch (...) {
61614       {
61615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61616       };
61617     }
61618   }
61619
61620   jresult = new Dali::Animation((const Dali::Animation &)result);
61621
61622   //argout typemap for const std::string&
61623
61624   return jresult;
61625 }
61626
61627
61628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61629   void * jresult ;
61630   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61631   std::string *arg2 = 0 ;
61632   Dali::Property::Map *arg3 = 0 ;
61633   Dali::Actor arg4 ;
61634   Dali::Actor *argp4 ;
61635   Dali::Animation result;
61636
61637   arg1 = (Dali::Toolkit::Builder *)jarg1;
61638   if (!jarg2) {
61639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61640     return 0;
61641   }
61642   std::string arg2_str(jarg2);
61643   arg2 = &arg2_str;
61644   arg3 = (Dali::Property::Map *)jarg3;
61645   if (!arg3) {
61646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61647     return 0;
61648   }
61649   argp4 = (Dali::Actor *)jarg4;
61650   if (!argp4) {
61651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61652     return 0;
61653   }
61654   arg4 = *argp4;
61655   {
61656     try {
61657       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61658     } catch (std::out_of_range& e) {
61659       {
61660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61661       };
61662     } catch (std::exception& e) {
61663       {
61664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61665       };
61666     } catch (Dali::DaliException e) {
61667       {
61668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61669       };
61670     } catch (...) {
61671       {
61672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61673       };
61674     }
61675   }
61676
61677   jresult = new Dali::Animation((const Dali::Animation &)result);
61678
61679   //argout typemap for const std::string&
61680
61681   return jresult;
61682 }
61683
61684
61685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61686   void * jresult ;
61687   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61688   std::string *arg2 = 0 ;
61689   Dali::BaseHandle result;
61690
61691   arg1 = (Dali::Toolkit::Builder *)jarg1;
61692   if (!jarg2) {
61693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61694     return 0;
61695   }
61696   std::string arg2_str(jarg2);
61697   arg2 = &arg2_str;
61698   {
61699     try {
61700       result = (arg1)->Create((std::string const &)*arg2);
61701     } catch (std::out_of_range& e) {
61702       {
61703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61704       };
61705     } catch (std::exception& e) {
61706       {
61707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61708       };
61709     } catch (Dali::DaliException e) {
61710       {
61711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61712       };
61713     } catch (...) {
61714       {
61715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61716       };
61717     }
61718   }
61719
61720   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61721
61722   //argout typemap for const std::string&
61723
61724   return jresult;
61725 }
61726
61727
61728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61729   void * jresult ;
61730   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61731   std::string *arg2 = 0 ;
61732   Dali::Property::Map *arg3 = 0 ;
61733   Dali::BaseHandle result;
61734
61735   arg1 = (Dali::Toolkit::Builder *)jarg1;
61736   if (!jarg2) {
61737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61738     return 0;
61739   }
61740   std::string arg2_str(jarg2);
61741   arg2 = &arg2_str;
61742   arg3 = (Dali::Property::Map *)jarg3;
61743   if (!arg3) {
61744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61745     return 0;
61746   }
61747   {
61748     try {
61749       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61750     } catch (std::out_of_range& e) {
61751       {
61752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61753       };
61754     } catch (std::exception& e) {
61755       {
61756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61757       };
61758     } catch (Dali::DaliException e) {
61759       {
61760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61761       };
61762     } catch (...) {
61763       {
61764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61765       };
61766     }
61767   }
61768
61769   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61770
61771   //argout typemap for const std::string&
61772
61773   return jresult;
61774 }
61775
61776
61777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61778   void * jresult ;
61779   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61780   std::string *arg2 = 0 ;
61781   Dali::BaseHandle result;
61782
61783   arg1 = (Dali::Toolkit::Builder *)jarg1;
61784   if (!jarg2) {
61785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61786     return 0;
61787   }
61788   std::string arg2_str(jarg2);
61789   arg2 = &arg2_str;
61790   {
61791     try {
61792       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61793     } catch (std::out_of_range& e) {
61794       {
61795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61796       };
61797     } catch (std::exception& e) {
61798       {
61799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61800       };
61801     } catch (Dali::DaliException e) {
61802       {
61803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61804       };
61805     } catch (...) {
61806       {
61807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61808       };
61809     }
61810   }
61811
61812   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61813
61814   //argout typemap for const std::string&
61815
61816   return jresult;
61817 }
61818
61819
61820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61821   unsigned int jresult ;
61822   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61823   std::string *arg2 = 0 ;
61824   Dali::Handle *arg3 = 0 ;
61825   bool result;
61826
61827   arg1 = (Dali::Toolkit::Builder *)jarg1;
61828   if (!jarg2) {
61829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61830     return 0;
61831   }
61832   std::string arg2_str(jarg2);
61833   arg2 = &arg2_str;
61834   arg3 = (Dali::Handle *)jarg3;
61835   if (!arg3) {
61836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61837     return 0;
61838   }
61839   {
61840     try {
61841       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61842     } catch (std::out_of_range& e) {
61843       {
61844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61845       };
61846     } catch (std::exception& e) {
61847       {
61848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61849       };
61850     } catch (Dali::DaliException e) {
61851       {
61852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61853       };
61854     } catch (...) {
61855       {
61856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61857       };
61858     }
61859   }
61860
61861   jresult = result;
61862
61863   //argout typemap for const std::string&
61864
61865   return jresult;
61866 }
61867
61868
61869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61870   unsigned int jresult ;
61871   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61872   Dali::Handle *arg2 = 0 ;
61873   std::string *arg3 = 0 ;
61874   bool result;
61875
61876   arg1 = (Dali::Toolkit::Builder *)jarg1;
61877   arg2 = (Dali::Handle *)jarg2;
61878   if (!arg2) {
61879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61880     return 0;
61881   }
61882   if (!jarg3) {
61883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61884     return 0;
61885   }
61886   std::string arg3_str(jarg3);
61887   arg3 = &arg3_str;
61888   {
61889     try {
61890       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61891     } catch (std::out_of_range& e) {
61892       {
61893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61894       };
61895     } catch (std::exception& e) {
61896       {
61897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61898       };
61899     } catch (Dali::DaliException e) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61902       };
61903     } catch (...) {
61904       {
61905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61906       };
61907     }
61908   }
61909
61910   jresult = result;
61911
61912   //argout typemap for const std::string&
61913
61914   return jresult;
61915 }
61916
61917
61918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61919   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61920   Dali::Actor arg2 ;
61921   Dali::Actor *argp2 ;
61922
61923   arg1 = (Dali::Toolkit::Builder *)jarg1;
61924   argp2 = (Dali::Actor *)jarg2;
61925   if (!argp2) {
61926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61927     return ;
61928   }
61929   arg2 = *argp2;
61930   {
61931     try {
61932       (arg1)->AddActors(arg2);
61933     } catch (std::out_of_range& e) {
61934       {
61935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61936       };
61937     } catch (std::exception& e) {
61938       {
61939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61940       };
61941     } catch (Dali::DaliException e) {
61942       {
61943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61944       };
61945     } catch (...) {
61946       {
61947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61948       };
61949     }
61950   }
61951
61952 }
61953
61954
61955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61956   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61957   std::string *arg2 = 0 ;
61958   Dali::Actor arg3 ;
61959   Dali::Actor *argp3 ;
61960
61961   arg1 = (Dali::Toolkit::Builder *)jarg1;
61962   if (!jarg2) {
61963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61964     return ;
61965   }
61966   std::string arg2_str(jarg2);
61967   arg2 = &arg2_str;
61968   argp3 = (Dali::Actor *)jarg3;
61969   if (!argp3) {
61970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61971     return ;
61972   }
61973   arg3 = *argp3;
61974   {
61975     try {
61976       (arg1)->AddActors((std::string const &)*arg2,arg3);
61977     } catch (std::out_of_range& e) {
61978       {
61979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61980       };
61981     } catch (std::exception& e) {
61982       {
61983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61984       };
61985     } catch (Dali::DaliException e) {
61986       {
61987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61988       };
61989     } catch (...) {
61990       {
61991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61992       };
61993     }
61994   }
61995
61996
61997   //argout typemap for const std::string&
61998
61999 }
62000
62001
62002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62003   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62004   std::string *arg2 = 0 ;
62005
62006   arg1 = (Dali::Toolkit::Builder *)jarg1;
62007   if (!jarg2) {
62008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62009     return ;
62010   }
62011   std::string arg2_str(jarg2);
62012   arg2 = &arg2_str;
62013   {
62014     try {
62015       (arg1)->CreateRenderTask((std::string const &)*arg2);
62016     } catch (std::out_of_range& e) {
62017       {
62018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62019       };
62020     } catch (std::exception& e) {
62021       {
62022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62023       };
62024     } catch (Dali::DaliException e) {
62025       {
62026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62027       };
62028     } catch (...) {
62029       {
62030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62031       };
62032     }
62033   }
62034
62035
62036   //argout typemap for const std::string&
62037
62038 }
62039
62040
62041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62042   void * jresult ;
62043   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62044   std::string *arg2 = 0 ;
62045   Dali::Path result;
62046
62047   arg1 = (Dali::Toolkit::Builder *)jarg1;
62048   if (!jarg2) {
62049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62050     return 0;
62051   }
62052   std::string arg2_str(jarg2);
62053   arg2 = &arg2_str;
62054   {
62055     try {
62056       result = (arg1)->GetPath((std::string const &)*arg2);
62057     } catch (std::out_of_range& e) {
62058       {
62059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62060       };
62061     } catch (std::exception& e) {
62062       {
62063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62064       };
62065     } catch (Dali::DaliException e) {
62066       {
62067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62068       };
62069     } catch (...) {
62070       {
62071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62072       };
62073     }
62074   }
62075
62076   jresult = new Dali::Path((const Dali::Path &)result);
62077
62078   //argout typemap for const std::string&
62079
62080   return jresult;
62081 }
62082
62083
62084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62085   void * jresult ;
62086   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62087   std::string *arg2 = 0 ;
62088   Dali::PathConstrainer result;
62089
62090   arg1 = (Dali::Toolkit::Builder *)jarg1;
62091   if (!jarg2) {
62092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62093     return 0;
62094   }
62095   std::string arg2_str(jarg2);
62096   arg2 = &arg2_str;
62097   {
62098     try {
62099       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62100     } catch (std::out_of_range& e) {
62101       {
62102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62103       };
62104     } catch (std::exception& e) {
62105       {
62106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62107       };
62108     } catch (Dali::DaliException e) {
62109       {
62110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62111       };
62112     } catch (...) {
62113       {
62114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62115       };
62116     }
62117   }
62118
62119   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62120
62121   //argout typemap for const std::string&
62122
62123   return jresult;
62124 }
62125
62126
62127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62128   void * jresult ;
62129   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62130   std::string *arg2 = 0 ;
62131   Dali::LinearConstrainer result;
62132
62133   arg1 = (Dali::Toolkit::Builder *)jarg1;
62134   if (!jarg2) {
62135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62136     return 0;
62137   }
62138   std::string arg2_str(jarg2);
62139   arg2 = &arg2_str;
62140   {
62141     try {
62142       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62143     } catch (std::out_of_range& e) {
62144       {
62145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62146       };
62147     } catch (std::exception& e) {
62148       {
62149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62150       };
62151     } catch (Dali::DaliException e) {
62152       {
62153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62154       };
62155     } catch (...) {
62156       {
62157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62158       };
62159     }
62160   }
62161
62162   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62163
62164   //argout typemap for const std::string&
62165
62166   return jresult;
62167 }
62168
62169
62170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62171   void * jresult ;
62172   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62173   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62174
62175   arg1 = (Dali::Toolkit::Builder *)jarg1;
62176   {
62177     try {
62178       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62179     } catch (std::out_of_range& e) {
62180       {
62181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62182       };
62183     } catch (std::exception& e) {
62184       {
62185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62186       };
62187     } catch (Dali::DaliException e) {
62188       {
62189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62190       };
62191     } catch (...) {
62192       {
62193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62194       };
62195     }
62196   }
62197
62198   jresult = (void *)result;
62199   return jresult;
62200 }
62201
62202
62203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62204   void * jresult ;
62205   Dali::Toolkit::TransitionData *result = 0 ;
62206
62207   {
62208     try {
62209       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62210     } catch (std::out_of_range& e) {
62211       {
62212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62213       };
62214     } catch (std::exception& e) {
62215       {
62216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62217       };
62218     } catch (Dali::DaliException e) {
62219       {
62220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62221       };
62222     } catch (...) {
62223       {
62224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62225       };
62226     }
62227   }
62228
62229   jresult = (void *)result;
62230   return jresult;
62231 }
62232
62233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62234   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62235
62236   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62237   {
62238     try {
62239       delete arg1;
62240     } catch (std::out_of_range& e) {
62241       {
62242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62243       };
62244     } catch (std::exception& e) {
62245       {
62246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62247       };
62248     } catch (Dali::DaliException e) {
62249       {
62250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62251       };
62252     } catch (...) {
62253       {
62254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62255       };
62256     }
62257   }
62258
62259 }
62260
62261
62262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62263   void * jresult ;
62264   Dali::Property::Map *arg1 = 0 ;
62265   Dali::Toolkit::TransitionData result;
62266
62267   arg1 = (Dali::Property::Map *)jarg1;
62268   if (!arg1) {
62269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62270     return 0;
62271   }
62272   {
62273     try {
62274       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62275     } catch (std::out_of_range& e) {
62276       {
62277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62278       };
62279     } catch (std::exception& e) {
62280       {
62281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62282       };
62283     } catch (Dali::DaliException e) {
62284       {
62285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62286       };
62287     } catch (...) {
62288       {
62289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62290       };
62291     }
62292   }
62293
62294   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62295   return jresult;
62296 }
62297
62298
62299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62300   void * jresult ;
62301   Dali::Property::Array *arg1 = 0 ;
62302   Dali::Toolkit::TransitionData result;
62303
62304   arg1 = (Dali::Property::Array *)jarg1;
62305   if (!arg1) {
62306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62307     return 0;
62308   }
62309   {
62310     try {
62311       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62312     } catch (std::out_of_range& e) {
62313       {
62314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62315       };
62316     } catch (std::exception& e) {
62317       {
62318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62319       };
62320     } catch (Dali::DaliException e) {
62321       {
62322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62323       };
62324     } catch (...) {
62325       {
62326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62327       };
62328     }
62329   }
62330
62331   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62332   return jresult;
62333 }
62334
62335
62336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62337   void * jresult ;
62338   Dali::BaseHandle arg1 ;
62339   Dali::BaseHandle *argp1 ;
62340   Dali::Toolkit::TransitionData result;
62341
62342   argp1 = (Dali::BaseHandle *)jarg1;
62343   if (!argp1) {
62344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62345     return 0;
62346   }
62347   arg1 = *argp1;
62348   {
62349     try {
62350       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62351     } catch (std::out_of_range& e) {
62352       {
62353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62354       };
62355     } catch (std::exception& e) {
62356       {
62357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62358       };
62359     } catch (Dali::DaliException e) {
62360       {
62361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62362       };
62363     } catch (...) {
62364       {
62365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62366       };
62367     }
62368   }
62369
62370   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62371   return jresult;
62372 }
62373
62374
62375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62376   void * jresult ;
62377   Dali::Toolkit::TransitionData *arg1 = 0 ;
62378   Dali::Toolkit::TransitionData *result = 0 ;
62379
62380   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62381   if (!arg1) {
62382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62383     return 0;
62384   }
62385   {
62386     try {
62387       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62388     } catch (std::out_of_range& e) {
62389       {
62390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62391       };
62392     } catch (std::exception& e) {
62393       {
62394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (Dali::DaliException e) {
62397       {
62398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62399       };
62400     } catch (...) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62403       };
62404     }
62405   }
62406
62407   jresult = (void *)result;
62408   return jresult;
62409 }
62410
62411
62412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62413   void * jresult ;
62414   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62415   Dali::Toolkit::TransitionData *arg2 = 0 ;
62416   Dali::Toolkit::TransitionData *result = 0 ;
62417
62418   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62419   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62420   if (!arg2) {
62421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62422     return 0;
62423   }
62424   {
62425     try {
62426       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62427     } catch (std::out_of_range& e) {
62428       {
62429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62430       };
62431     } catch (std::exception& e) {
62432       {
62433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62434       };
62435     } catch (Dali::DaliException e) {
62436       {
62437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62438       };
62439     } catch (...) {
62440       {
62441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62442       };
62443     }
62444   }
62445
62446   jresult = (void *)result;
62447   return jresult;
62448 }
62449
62450
62451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62452   unsigned long jresult ;
62453   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62454   size_t result;
62455
62456   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62457   {
62458     try {
62459       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62460     } catch (std::out_of_range& e) {
62461       {
62462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62463       };
62464     } catch (std::exception& e) {
62465       {
62466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62467       };
62468     } catch (Dali::DaliException e) {
62469       {
62470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62471       };
62472     } catch (...) {
62473       {
62474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62475       };
62476     }
62477   }
62478
62479   jresult = (unsigned long)result;
62480   return jresult;
62481 }
62482
62483
62484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62485   void * jresult ;
62486   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62487   size_t arg2 ;
62488   Dali::Property::Map result;
62489
62490   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62491   arg2 = (size_t)jarg2;
62492   {
62493     try {
62494       result = (arg1)->GetAnimatorAt(arg2);
62495     } catch (std::out_of_range& e) {
62496       {
62497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62498       };
62499     } catch (std::exception& e) {
62500       {
62501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62502       };
62503     } catch (Dali::DaliException e) {
62504       {
62505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62506       };
62507     } catch (...) {
62508       {
62509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62510       };
62511     }
62512   }
62513
62514   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62515   return jresult;
62516 }
62517
62518
62519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62520   int jresult ;
62521   int result;
62522
62523   {
62524     try {
62525       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62526     } catch (std::out_of_range& e) {
62527       {
62528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62529       };
62530     } catch (std::exception& e) {
62531       {
62532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62533       };
62534     } catch (Dali::DaliException e) {
62535       {
62536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62537       };
62538     } catch (...) {
62539       {
62540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62541       };
62542     }
62543   }
62544
62545   jresult = (int)result;
62546   return jresult;
62547 }
62548
62549
62550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62551   int jresult ;
62552   int result;
62553
62554   {
62555     try {
62556       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62557     } catch (std::out_of_range& e) {
62558       {
62559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62560       };
62561     } catch (std::exception& e) {
62562       {
62563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (Dali::DaliException e) {
62566       {
62567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62568       };
62569     } catch (...) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62572       };
62573     }
62574   }
62575
62576   jresult = (int)result;
62577   return jresult;
62578 }
62579
62580
62581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62582   int jresult ;
62583   int result;
62584
62585   {
62586     try {
62587       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62588     } catch (std::out_of_range& e) {
62589       {
62590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62591       };
62592     } catch (std::exception& e) {
62593       {
62594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62595       };
62596     } catch (Dali::DaliException e) {
62597       {
62598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62599       };
62600     } catch (...) {
62601       {
62602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62603       };
62604     }
62605   }
62606
62607   jresult = (int)result;
62608   return jresult;
62609 }
62610
62611
62612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62613   int jresult ;
62614   int result;
62615
62616   {
62617     try {
62618       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62619     } catch (std::out_of_range& e) {
62620       {
62621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62622       };
62623     } catch (std::exception& e) {
62624       {
62625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62626       };
62627     } catch (Dali::DaliException e) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62630       };
62631     } catch (...) {
62632       {
62633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62634       };
62635     }
62636   }
62637
62638   jresult = (int)result;
62639   return jresult;
62640 }
62641
62642
62643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62644   int jresult ;
62645   int result;
62646
62647   {
62648     try {
62649       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62650     } catch (std::out_of_range& e) {
62651       {
62652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62653       };
62654     } catch (std::exception& e) {
62655       {
62656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62657       };
62658     } catch (Dali::DaliException e) {
62659       {
62660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62661       };
62662     } catch (...) {
62663       {
62664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62665       };
62666     }
62667   }
62668
62669   jresult = (int)result;
62670   return jresult;
62671 }
62672
62673
62674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62675   int jresult ;
62676   int result;
62677
62678   {
62679     try {
62680       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62681     } catch (std::out_of_range& e) {
62682       {
62683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62684       };
62685     } catch (std::exception& e) {
62686       {
62687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62688       };
62689     } catch (Dali::DaliException e) {
62690       {
62691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62692       };
62693     } catch (...) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62696       };
62697     }
62698   }
62699
62700   jresult = (int)result;
62701   return jresult;
62702 }
62703
62704
62705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62706   int jresult ;
62707   int result;
62708
62709   {
62710     try {
62711       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62712     } catch (std::out_of_range& e) {
62713       {
62714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62715       };
62716     } catch (std::exception& e) {
62717       {
62718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62719       };
62720     } catch (Dali::DaliException e) {
62721       {
62722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62723       };
62724     } catch (...) {
62725       {
62726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62727       };
62728     }
62729   }
62730
62731   jresult = (int)result;
62732   return jresult;
62733 }
62734
62735
62736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62737   int jresult ;
62738   int result;
62739
62740   {
62741     try {
62742       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62743     } catch (std::out_of_range& e) {
62744       {
62745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62746       };
62747     } catch (std::exception& e) {
62748       {
62749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62750       };
62751     } catch (Dali::DaliException e) {
62752       {
62753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62754       };
62755     } catch (...) {
62756       {
62757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62758       };
62759     }
62760   }
62761
62762   jresult = (int)result;
62763   return jresult;
62764 }
62765
62766
62767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62768   int jresult ;
62769   int result;
62770
62771   {
62772     try {
62773       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62774     } catch (std::out_of_range& e) {
62775       {
62776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62777       };
62778     } catch (std::exception& e) {
62779       {
62780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62781       };
62782     } catch (Dali::DaliException e) {
62783       {
62784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62785       };
62786     } catch (...) {
62787       {
62788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62789       };
62790     }
62791   }
62792
62793   jresult = (int)result;
62794   return jresult;
62795 }
62796
62797
62798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62799   int jresult ;
62800   int result;
62801
62802   {
62803     try {
62804       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62805     } catch (std::out_of_range& e) {
62806       {
62807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62808       };
62809     } catch (std::exception& e) {
62810       {
62811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62812       };
62813     } catch (Dali::DaliException e) {
62814       {
62815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62816       };
62817     } catch (...) {
62818       {
62819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62820       };
62821     }
62822   }
62823
62824   jresult = (int)result;
62825   return jresult;
62826 }
62827
62828
62829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62830   int jresult ;
62831   int result;
62832
62833   {
62834     try {
62835       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62836     } catch (std::out_of_range& e) {
62837       {
62838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62839       };
62840     } catch (std::exception& e) {
62841       {
62842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62843       };
62844     } catch (Dali::DaliException e) {
62845       {
62846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62847       };
62848     } catch (...) {
62849       {
62850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62851       };
62852     }
62853   }
62854
62855   jresult = (int)result;
62856   return jresult;
62857 }
62858
62859
62860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62861   int jresult ;
62862   int result;
62863
62864   {
62865     try {
62866       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62867     } catch (std::out_of_range& e) {
62868       {
62869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62870       };
62871     } catch (std::exception& e) {
62872       {
62873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62874       };
62875     } catch (Dali::DaliException e) {
62876       {
62877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62878       };
62879     } catch (...) {
62880       {
62881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62882       };
62883     }
62884   }
62885
62886   jresult = (int)result;
62887   return jresult;
62888 }
62889
62890
62891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62892   int jresult ;
62893   int result;
62894
62895   {
62896     try {
62897       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62898     } catch (std::out_of_range& e) {
62899       {
62900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62901       };
62902     } catch (std::exception& e) {
62903       {
62904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62905       };
62906     } catch (Dali::DaliException e) {
62907       {
62908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62909       };
62910     } catch (...) {
62911       {
62912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62913       };
62914     }
62915   }
62916
62917   jresult = (int)result;
62918   return jresult;
62919 }
62920
62921
62922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62923   int jresult ;
62924   int result;
62925
62926   {
62927     try {
62928       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62929     } catch (std::out_of_range& e) {
62930       {
62931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62932       };
62933     } catch (std::exception& e) {
62934       {
62935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62936       };
62937     } catch (Dali::DaliException e) {
62938       {
62939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62940       };
62941     } catch (...) {
62942       {
62943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62944       };
62945     }
62946   }
62947
62948   jresult = (int)result;
62949   return jresult;
62950 }
62951
62952
62953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62954   void * jresult ;
62955   Dali::Toolkit::Control result;
62956
62957   {
62958     try {
62959       result = Dali::Toolkit::Internal::Control::New();
62960     } catch (std::out_of_range& e) {
62961       {
62962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62963       };
62964     } catch (std::exception& e) {
62965       {
62966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62967       };
62968     } catch (Dali::DaliException e) {
62969       {
62970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62971       };
62972     } catch (...) {
62973       {
62974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62975       };
62976     }
62977   }
62978
62979   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62980   return jresult;
62981 }
62982
62983
62984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62986   std::string *arg2 = 0 ;
62987
62988   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62989   if (!jarg2) {
62990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62991     return ;
62992   }
62993   std::string arg2_str(jarg2);
62994   arg2 = &arg2_str;
62995   {
62996     try {
62997       (arg1)->SetStyleName((std::string const &)*arg2);
62998     } catch (std::out_of_range& e) {
62999       {
63000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63001       };
63002     } catch (std::exception& e) {
63003       {
63004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63005       };
63006     } catch (Dali::DaliException e) {
63007       {
63008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63009       };
63010     } catch (...) {
63011       {
63012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63013       };
63014     }
63015   }
63016
63017
63018   //argout typemap for const std::string&
63019
63020 }
63021
63022
63023 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63024   char * jresult ;
63025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63026   std::string *result = 0 ;
63027
63028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63029   {
63030     try {
63031       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63032     } catch (std::out_of_range& e) {
63033       {
63034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63035       };
63036     } catch (std::exception& e) {
63037       {
63038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (Dali::DaliException e) {
63041       {
63042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63043       };
63044     } catch (...) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63047       };
63048     }
63049   }
63050
63051   jresult = SWIG_csharp_string_callback(result->c_str());
63052   return jresult;
63053 }
63054
63055
63056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63057   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63058   Dali::Vector4 *arg2 = 0 ;
63059
63060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63061   arg2 = (Dali::Vector4 *)jarg2;
63062   if (!arg2) {
63063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63064     return ;
63065   }
63066   {
63067     try {
63068       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63069     } catch (std::out_of_range& e) {
63070       {
63071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63072       };
63073     } catch (std::exception& e) {
63074       {
63075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63076       };
63077     } catch (Dali::DaliException e) {
63078       {
63079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63080       };
63081     } catch (...) {
63082       {
63083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63084       };
63085     }
63086   }
63087
63088 }
63089
63090
63091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63092   void * jresult ;
63093   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63094   Dali::Vector4 result;
63095
63096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63097   {
63098     try {
63099       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63100     } catch (std::out_of_range& e) {
63101       {
63102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63103       };
63104     } catch (std::exception& e) {
63105       {
63106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63107       };
63108     } catch (Dali::DaliException e) {
63109       {
63110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63111       };
63112     } catch (...) {
63113       {
63114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63115       };
63116     }
63117   }
63118
63119   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63120   return jresult;
63121 }
63122
63123
63124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63125   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63126   Dali::Image arg2 ;
63127   Dali::Image *argp2 ;
63128
63129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63130   argp2 = (Dali::Image *)jarg2;
63131   if (!argp2) {
63132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63133     return ;
63134   }
63135   arg2 = *argp2;
63136   {
63137     try {
63138       (arg1)->SetBackgroundImage(arg2);
63139     } catch (std::out_of_range& e) {
63140       {
63141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63142       };
63143     } catch (std::exception& e) {
63144       {
63145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63146       };
63147     } catch (Dali::DaliException e) {
63148       {
63149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63150       };
63151     } catch (...) {
63152       {
63153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63154       };
63155     }
63156   }
63157
63158 }
63159
63160
63161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63162   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63163   Dali::Property::Map *arg2 = 0 ;
63164
63165   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63166   arg2 = (Dali::Property::Map *)jarg2;
63167   if (!arg2) {
63168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63169     return ;
63170   }
63171   {
63172     try {
63173       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63174     } catch (std::out_of_range& e) {
63175       {
63176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63177       };
63178     } catch (std::exception& e) {
63179       {
63180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63181       };
63182     } catch (Dali::DaliException e) {
63183       {
63184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63185       };
63186     } catch (...) {
63187       {
63188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63189       };
63190     }
63191   }
63192
63193 }
63194
63195
63196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63197   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63198
63199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63200   {
63201     try {
63202       (arg1)->ClearBackground();
63203     } catch (std::out_of_range& e) {
63204       {
63205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63206       };
63207     } catch (std::exception& e) {
63208       {
63209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63210       };
63211     } catch (Dali::DaliException e) {
63212       {
63213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63214       };
63215     } catch (...) {
63216       {
63217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63218       };
63219     }
63220   }
63221
63222 }
63223
63224
63225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63226   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63227   Dali::Gesture::Type arg2 ;
63228
63229   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63230   arg2 = (Dali::Gesture::Type)jarg2;
63231   {
63232     try {
63233       (arg1)->EnableGestureDetection(arg2);
63234     } catch (std::out_of_range& e) {
63235       {
63236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63237       };
63238     } catch (std::exception& e) {
63239       {
63240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63241       };
63242     } catch (Dali::DaliException e) {
63243       {
63244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63245       };
63246     } catch (...) {
63247       {
63248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63249       };
63250     }
63251   }
63252
63253 }
63254
63255
63256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63258   Dali::Gesture::Type arg2 ;
63259
63260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63261   arg2 = (Dali::Gesture::Type)jarg2;
63262   {
63263     try {
63264       (arg1)->DisableGestureDetection(arg2);
63265     } catch (std::out_of_range& e) {
63266       {
63267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63268       };
63269     } catch (std::exception& e) {
63270       {
63271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63272       };
63273     } catch (Dali::DaliException e) {
63274       {
63275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63276       };
63277     } catch (...) {
63278       {
63279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63280       };
63281     }
63282   }
63283
63284 }
63285
63286
63287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63288   void * jresult ;
63289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63290   Dali::PinchGestureDetector result;
63291
63292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63293   {
63294     try {
63295       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63296     } catch (std::out_of_range& e) {
63297       {
63298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63299       };
63300     } catch (std::exception& e) {
63301       {
63302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63303       };
63304     } catch (Dali::DaliException e) {
63305       {
63306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63307       };
63308     } catch (...) {
63309       {
63310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63311       };
63312     }
63313   }
63314
63315   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63316   return jresult;
63317 }
63318
63319
63320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63321   void * jresult ;
63322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63323   Dali::PanGestureDetector result;
63324
63325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63326   {
63327     try {
63328       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63329     } catch (std::out_of_range& e) {
63330       {
63331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63332       };
63333     } catch (std::exception& e) {
63334       {
63335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63336       };
63337     } catch (Dali::DaliException e) {
63338       {
63339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63340       };
63341     } catch (...) {
63342       {
63343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63344       };
63345     }
63346   }
63347
63348   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63349   return jresult;
63350 }
63351
63352
63353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63354   void * jresult ;
63355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63356   Dali::TapGestureDetector result;
63357
63358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63359   {
63360     try {
63361       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63362     } catch (std::out_of_range& e) {
63363       {
63364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63365       };
63366     } catch (std::exception& e) {
63367       {
63368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63369       };
63370     } catch (Dali::DaliException e) {
63371       {
63372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63373       };
63374     } catch (...) {
63375       {
63376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63377       };
63378     }
63379   }
63380
63381   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63382   return jresult;
63383 }
63384
63385
63386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63387   void * jresult ;
63388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63389   Dali::LongPressGestureDetector result;
63390
63391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63392   {
63393     try {
63394       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63395     } catch (std::out_of_range& e) {
63396       {
63397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63398       };
63399     } catch (std::exception& e) {
63400       {
63401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63402       };
63403     } catch (Dali::DaliException e) {
63404       {
63405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63406       };
63407     } catch (...) {
63408       {
63409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63410       };
63411     }
63412   }
63413
63414   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63415   return jresult;
63416 }
63417
63418
63419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63421   bool arg2 ;
63422
63423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63424   arg2 = jarg2 ? true : false;
63425   {
63426     try {
63427       (arg1)->SetKeyboardNavigationSupport(arg2);
63428     } catch (std::out_of_range& e) {
63429       {
63430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63431       };
63432     } catch (std::exception& e) {
63433       {
63434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63435       };
63436     } catch (Dali::DaliException e) {
63437       {
63438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63439       };
63440     } catch (...) {
63441       {
63442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63443       };
63444     }
63445   }
63446
63447 }
63448
63449
63450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63451   unsigned int jresult ;
63452   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63453   bool result;
63454
63455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63456   {
63457     try {
63458       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63459     } catch (std::out_of_range& e) {
63460       {
63461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63462       };
63463     } catch (std::exception& e) {
63464       {
63465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63466       };
63467     } catch (Dali::DaliException e) {
63468       {
63469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63470       };
63471     } catch (...) {
63472       {
63473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63474       };
63475     }
63476   }
63477
63478   jresult = result;
63479   return jresult;
63480 }
63481
63482
63483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63485
63486   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63487   {
63488     try {
63489       (arg1)->SetKeyInputFocus();
63490     } catch (std::out_of_range& e) {
63491       {
63492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63493       };
63494     } catch (std::exception& e) {
63495       {
63496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63497       };
63498     } catch (Dali::DaliException e) {
63499       {
63500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63501       };
63502     } catch (...) {
63503       {
63504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63505       };
63506     }
63507   }
63508
63509 }
63510
63511
63512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63513   unsigned int jresult ;
63514   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63515   bool result;
63516
63517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63518   {
63519     try {
63520       result = (bool)(arg1)->HasKeyInputFocus();
63521     } catch (std::out_of_range& e) {
63522       {
63523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63524       };
63525     } catch (std::exception& e) {
63526       {
63527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63528       };
63529     } catch (Dali::DaliException e) {
63530       {
63531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63532       };
63533     } catch (...) {
63534       {
63535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63536       };
63537     }
63538   }
63539
63540   jresult = result;
63541   return jresult;
63542 }
63543
63544
63545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63547
63548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63549   {
63550     try {
63551       (arg1)->ClearKeyInputFocus();
63552     } catch (std::out_of_range& e) {
63553       {
63554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63555       };
63556     } catch (std::exception& e) {
63557       {
63558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63559       };
63560     } catch (Dali::DaliException e) {
63561       {
63562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63563       };
63564     } catch (...) {
63565       {
63566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63567       };
63568     }
63569   }
63570
63571 }
63572
63573
63574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63576   bool arg2 ;
63577
63578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63579   arg2 = jarg2 ? true : false;
63580   {
63581     try {
63582       (arg1)->SetAsKeyboardFocusGroup(arg2);
63583     } catch (std::out_of_range& e) {
63584       {
63585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63586       };
63587     } catch (std::exception& e) {
63588       {
63589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63590       };
63591     } catch (Dali::DaliException e) {
63592       {
63593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63594       };
63595     } catch (...) {
63596       {
63597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63598       };
63599     }
63600   }
63601
63602 }
63603
63604
63605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63606   unsigned int jresult ;
63607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63608   bool result;
63609
63610   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63611   {
63612     try {
63613       result = (bool)(arg1)->IsKeyboardFocusGroup();
63614     } catch (std::out_of_range& e) {
63615       {
63616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63617       };
63618     } catch (std::exception& e) {
63619       {
63620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63621       };
63622     } catch (Dali::DaliException e) {
63623       {
63624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63625       };
63626     } catch (...) {
63627       {
63628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63629       };
63630     }
63631   }
63632
63633   jresult = result;
63634   return jresult;
63635 }
63636
63637
63638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63639   void * jresult ;
63640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63641   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63642
63643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63644   {
63645     try {
63646       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63647     } catch (std::out_of_range& e) {
63648       {
63649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63650       };
63651     } catch (std::exception& e) {
63652       {
63653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63654       };
63655     } catch (Dali::DaliException e) {
63656       {
63657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63658       };
63659     } catch (...) {
63660       {
63661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63662       };
63663     }
63664   }
63665
63666   jresult = (void *)result;
63667   return jresult;
63668 }
63669
63670
63671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63672   void * jresult ;
63673   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63674   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63675
63676   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63677   {
63678     try {
63679       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63680     } catch (std::out_of_range& e) {
63681       {
63682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63683       };
63684     } catch (std::exception& e) {
63685       {
63686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63687       };
63688     } catch (Dali::DaliException e) {
63689       {
63690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63691       };
63692     } catch (...) {
63693       {
63694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63695       };
63696     }
63697   }
63698
63699   jresult = (void *)result;
63700   return jresult;
63701 }
63702
63703
63704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63705   void * jresult ;
63706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63707   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63708
63709   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63710   {
63711     try {
63712       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63713     } catch (std::out_of_range& e) {
63714       {
63715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63716       };
63717     } catch (std::exception& e) {
63718       {
63719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63720       };
63721     } catch (Dali::DaliException e) {
63722       {
63723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63724       };
63725     } catch (...) {
63726       {
63727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63728       };
63729     }
63730   }
63731
63732   jresult = (void *)result;
63733   return jresult;
63734 }
63735
63736
63737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63739   int arg2 ;
63740   SwigDirector_ViewImpl *darg = 0;
63741
63742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63743   arg2 = (int)jarg2;
63744   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63745   if(!darg) {
63746     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63747     return;
63748   }
63749   {
63750     try {
63751       if(darg) {
63752         (darg)->OnStageConnection(arg2);
63753       }
63754     } catch (std::out_of_range& e) {
63755       {
63756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63757       };
63758     } catch (std::exception& e) {
63759       {
63760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63761       };
63762     } catch (Dali::DaliException e) {
63763       {
63764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63765       };
63766     } catch (...) {
63767       {
63768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63769       };
63770     }
63771   }
63772
63773 }
63774
63775
63776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63778   int arg2 ;
63779   SwigDirector_ViewImpl *darg = 0;
63780
63781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63782   arg2 = (int)jarg2;
63783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63784   if(!darg) {
63785     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63786     return;
63787   }
63788   {
63789     try {
63790       if(darg) {
63791         (darg)->OnStageConnectionSwigPublic(arg2);
63792       }
63793     } catch (std::out_of_range& e) {
63794       {
63795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63796       };
63797     } catch (std::exception& e) {
63798       {
63799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63800       };
63801     } catch (Dali::DaliException e) {
63802       {
63803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63804       };
63805     } catch (...) {
63806       {
63807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63808       };
63809     }
63810   }
63811
63812 }
63813
63814
63815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63816   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63817   SwigDirector_ViewImpl *darg = 0;
63818
63819   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63820   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63821   if(!darg) {
63822     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63823     return;
63824   }
63825   {
63826     try {
63827       if(darg) {
63828         (darg)->OnStageDisconnection();
63829       }
63830     } catch (std::out_of_range& e) {
63831       {
63832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63833       };
63834     } catch (std::exception& e) {
63835       {
63836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63837       };
63838     } catch (Dali::DaliException e) {
63839       {
63840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63841       };
63842     } catch (...) {
63843       {
63844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63845       };
63846     }
63847   }
63848
63849 }
63850
63851
63852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63854   SwigDirector_ViewImpl *darg = 0;
63855
63856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63857   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63858   if(!darg) {
63859     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63860     return;
63861   }
63862   {
63863     try {
63864       if(darg) {
63865         (darg)->OnStageDisconnectionSwigPublic();
63866       }
63867     } catch (std::out_of_range& e) {
63868       {
63869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63870       };
63871     } catch (std::exception& e) {
63872       {
63873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63874       };
63875     } catch (Dali::DaliException e) {
63876       {
63877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63878       };
63879     } catch (...) {
63880       {
63881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63882       };
63883     }
63884   }
63885
63886 }
63887
63888
63889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63891   Dali::Actor *arg2 = 0 ;
63892   SwigDirector_ViewImpl *darg = 0;
63893
63894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63895   arg2 = (Dali::Actor *)jarg2;
63896   if (!arg2) {
63897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63898     return ;
63899   }
63900   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63901   if(!darg) {
63902     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63903     return;
63904   }
63905   {
63906     try {
63907       if(darg) {
63908         (darg)->OnChildAdd(*arg2);
63909       }
63910     } catch (std::out_of_range& e) {
63911       {
63912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63913       };
63914     } catch (std::exception& e) {
63915       {
63916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63917       };
63918     } catch (Dali::DaliException e) {
63919       {
63920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63921       };
63922     } catch (...) {
63923       {
63924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63925       };
63926     }
63927   }
63928
63929 }
63930
63931
63932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63933   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63934   Dali::Actor *arg2 = 0 ;
63935   SwigDirector_ViewImpl *darg = 0;
63936
63937   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63938   arg2 = (Dali::Actor *)jarg2;
63939   if (!arg2) {
63940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63941     return ;
63942   }
63943   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63944   if(!darg) {
63945     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63946     return;
63947   }
63948   {
63949     try {
63950       if(darg) {
63951           (darg)->OnChildAddSwigPublic(*arg2);
63952       }
63953     } catch (std::out_of_range& e) {
63954       {
63955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63956       };
63957     } catch (std::exception& e) {
63958       {
63959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63960       };
63961     } catch (Dali::DaliException e) {
63962       {
63963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63964       };
63965     } catch (...) {
63966       {
63967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63968       };
63969     }
63970   }
63971
63972 }
63973
63974
63975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63977   Dali::Actor *arg2 = 0 ;
63978   SwigDirector_ViewImpl *darg = 0;
63979
63980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63981   arg2 = (Dali::Actor *)jarg2;
63982   if (!arg2) {
63983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63984     return ;
63985   }
63986   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63987   if(!darg) {
63988     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63989     return;
63990   }
63991   {
63992     try {
63993       if(darg) {
63994         (darg)->OnChildRemove(*arg2);
63995       }
63996     } catch (std::out_of_range& e) {
63997       {
63998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63999       };
64000     } catch (std::exception& e) {
64001       {
64002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64003       };
64004     } catch (Dali::DaliException e) {
64005       {
64006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64007       };
64008     } catch (...) {
64009       {
64010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64011       };
64012     }
64013   }
64014
64015 }
64016
64017
64018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64019   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64020   Dali::Actor *arg2 = 0 ;
64021   SwigDirector_ViewImpl *darg = 0;
64022
64023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64024   arg2 = (Dali::Actor *)jarg2;
64025   if (!arg2) {
64026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64027     return ;
64028   }
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       if(darg) {
64037         (darg)->OnChildRemoveSwigPublic(*arg2);
64038       }
64039     } catch (std::out_of_range& e) {
64040       {
64041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64042       };
64043     } catch (std::exception& e) {
64044       {
64045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64046       };
64047     } catch (Dali::DaliException e) {
64048       {
64049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64050       };
64051     } catch (...) {
64052       {
64053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64054       };
64055     }
64056   }
64057
64058 }
64059
64060
64061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64063   Dali::Property::Index arg2 ;
64064   Dali::Property::Value arg3 ;
64065   Dali::Property::Value *argp3 ;
64066   SwigDirector_ViewImpl *darg = 0;
64067
64068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64069   arg2 = (Dali::Property::Index)jarg2;
64070   argp3 = (Dali::Property::Value *)jarg3;
64071   if (!argp3) {
64072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64073     return ;
64074   }
64075   arg3 = *argp3;
64076   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64077   if (!darg) {
64078     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64079     return;
64080   }
64081   {
64082     try {
64083       (darg)->OnPropertySet(arg2,arg3);
64084     } catch (std::out_of_range& e) {
64085       {
64086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64087       };
64088     } catch (std::exception& e) {
64089       {
64090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64091       };
64092     } catch (Dali::DaliException e) {
64093       {
64094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64095       };
64096     } catch (...) {
64097       {
64098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64099       };
64100     }
64101   }
64102
64103 }
64104
64105
64106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64107   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64108   Dali::Property::Index arg2 ;
64109   Dali::Property::Value arg3 ;
64110   Dali::Property::Value *argp3 ;
64111   SwigDirector_ViewImpl *darg = 0;
64112
64113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64114   arg2 = (Dali::Property::Index)jarg2;
64115   argp3 = (Dali::Property::Value *)jarg3;
64116   if (!argp3) {
64117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64118     return ;
64119   }
64120   arg3 = *argp3;
64121   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64122   if (!darg) {
64123     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64124     return;
64125   }
64126   {
64127     try {
64128       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64129     } catch (std::out_of_range& e) {
64130       {
64131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64132       };
64133     } catch (std::exception& e) {
64134       {
64135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64136       };
64137     } catch (Dali::DaliException e) {
64138       {
64139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64140       };
64141     } catch (...) {
64142       {
64143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64144       };
64145     }
64146   }
64147
64148 }
64149
64150
64151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64152   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64153   Dali::Vector3 *arg2 = 0 ;
64154   SwigDirector_ViewImpl *darg = 0;
64155
64156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64157   arg2 = (Dali::Vector3 *)jarg2;
64158   if (!arg2) {
64159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64160     return ;
64161   }
64162   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64163   if (!darg) {
64164     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64165     return;
64166   }
64167   {
64168     try {
64169       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64170     } catch (std::out_of_range& e) {
64171       {
64172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64173       };
64174     } catch (std::exception& e) {
64175       {
64176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64177       };
64178     } catch (Dali::DaliException e) {
64179       {
64180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64181       };
64182     } catch (...) {
64183       {
64184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64185       };
64186     }
64187   }
64188
64189 }
64190
64191
64192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64194   Dali::Vector3 *arg2 = 0 ;
64195   SwigDirector_ViewImpl *darg = 0;
64196
64197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64198   arg2 = (Dali::Vector3 *)jarg2;
64199   if (!arg2) {
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)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
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_OnSizeAnimation(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)->OnSizeAnimation(*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 void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64281   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64282   Dali::Animation *arg2 = 0 ;
64283   Dali::Vector3 *arg3 = 0 ;
64284   SwigDirector_ViewImpl *darg = 0;
64285
64286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64287   arg2 = (Dali::Animation *)jarg2;
64288   if (!arg2) {
64289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64290     return ;
64291   }
64292   arg3 = (Dali::Vector3 *)jarg3;
64293   if (!arg3) {
64294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64295     return ;
64296   }
64297   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64298   if (!darg) {
64299     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64300     return;
64301   }
64302   {
64303     try {
64304       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64305     } catch (std::out_of_range& e) {
64306       {
64307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64308       };
64309     } catch (std::exception& e) {
64310       {
64311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64312       };
64313     } catch (Dali::DaliException e) {
64314       {
64315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64316       };
64317     } catch (...) {
64318       {
64319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64320       };
64321     }
64322   }
64323
64324 }
64325
64326
64327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64328   unsigned int jresult ;
64329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64330   Dali::TouchEvent *arg2 = 0 ;
64331   SwigDirector_ViewImpl *darg = 0;
64332   bool result;
64333
64334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64335   arg2 = (Dali::TouchEvent *)jarg2;
64336   if (!arg2) {
64337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64338     return 0;
64339   }
64340   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64341   if (!darg) {
64342     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64343     return 0;
64344   }
64345   {
64346     try {
64347       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64348     } catch (std::out_of_range& e) {
64349       {
64350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64351       };
64352     } catch (std::exception& e) {
64353       {
64354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64355       };
64356     } catch (Dali::DaliException e) {
64357       {
64358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64359       };
64360     } catch (...) {
64361       {
64362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64363       };
64364     }
64365   }
64366
64367   jresult = result;
64368   return jresult;
64369 }
64370
64371
64372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64373   unsigned int jresult ;
64374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64375   Dali::TouchEvent *arg2 = 0 ;
64376   SwigDirector_ViewImpl *darg = 0;
64377   bool result;
64378
64379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64380   arg2 = (Dali::TouchEvent *)jarg2;
64381   if (!arg2) {
64382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64383     return 0;
64384   }
64385   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64386   if (!darg) {
64387     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64388     return 0;
64389   }
64390   {
64391     try {
64392       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64393     } catch (std::out_of_range& e) {
64394       {
64395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64396       };
64397     } catch (std::exception& e) {
64398       {
64399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64400       };
64401     } catch (Dali::DaliException e) {
64402       {
64403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64404       };
64405     } catch (...) {
64406       {
64407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64408       };
64409     }
64410   }
64411
64412   jresult = result;
64413   return jresult;
64414 }
64415
64416
64417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64418   unsigned int jresult ;
64419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64420   Dali::HoverEvent *arg2 = 0 ;
64421   SwigDirector_ViewImpl *darg = 0;
64422   bool result;
64423
64424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64425   arg2 = (Dali::HoverEvent *)jarg2;
64426   if (!arg2) {
64427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64428     return 0;
64429   }
64430   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64431   if (!darg) {
64432     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64433     return 0;
64434   }
64435   {
64436     try {
64437       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64438     } catch (std::out_of_range& e) {
64439       {
64440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64441       };
64442     } catch (std::exception& e) {
64443       {
64444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64445       };
64446     } catch (Dali::DaliException e) {
64447       {
64448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64449       };
64450     } catch (...) {
64451       {
64452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64453       };
64454     }
64455   }
64456
64457   jresult = result;
64458   return jresult;
64459 }
64460
64461
64462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64463   unsigned int jresult ;
64464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64465   Dali::HoverEvent *arg2 = 0 ;
64466   SwigDirector_ViewImpl *darg = 0;
64467   bool result;
64468
64469   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64470   arg2 = (Dali::HoverEvent *)jarg2;
64471   if (!arg2) {
64472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64473     return 0;
64474   }
64475   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64476   if (!darg) {
64477     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64478     return 0;
64479   }
64480   {
64481     try {
64482       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64483     } catch (std::out_of_range& e) {
64484       {
64485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64486       };
64487     } catch (std::exception& e) {
64488       {
64489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64490       };
64491     } catch (Dali::DaliException e) {
64492       {
64493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64494       };
64495     } catch (...) {
64496       {
64497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64498       };
64499     }
64500   }
64501
64502   jresult = result;
64503   return jresult;
64504 }
64505
64506
64507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64508   unsigned int jresult ;
64509   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64510   Dali::KeyEvent *arg2 = 0 ;
64511   SwigDirector_ViewImpl *darg = 0;
64512   bool result;
64513
64514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64515   arg2 = (Dali::KeyEvent *)jarg2;
64516   if (!arg2) {
64517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64518     return 0;
64519   }
64520   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64521   if (!darg) {
64522     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64523     return 0;
64524   }
64525   {
64526     try {
64527       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64528     } catch (std::out_of_range& e) {
64529       {
64530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64531       };
64532     } catch (std::exception& e) {
64533       {
64534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64535       };
64536     } catch (Dali::DaliException e) {
64537       {
64538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64539       };
64540     } catch (...) {
64541       {
64542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64543       };
64544     }
64545   }
64546
64547   jresult = result;
64548   return jresult;
64549 }
64550
64551
64552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64553   unsigned int jresult ;
64554   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64555   Dali::KeyEvent *arg2 = 0 ;
64556   SwigDirector_ViewImpl *darg = 0;
64557   bool result;
64558
64559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64560   arg2 = (Dali::KeyEvent *)jarg2;
64561   if (!arg2) {
64562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64563     return 0;
64564   }
64565   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64566   if (!darg) {
64567     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64568     return 0;
64569   }
64570   {
64571     try {
64572       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64573     } catch (std::out_of_range& e) {
64574       {
64575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64576       };
64577     } catch (std::exception& e) {
64578       {
64579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64580       };
64581     } catch (Dali::DaliException e) {
64582       {
64583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64584       };
64585     } catch (...) {
64586       {
64587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64588       };
64589     }
64590   }
64591
64592   jresult = result;
64593   return jresult;
64594 }
64595
64596
64597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64598   unsigned int jresult ;
64599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64600   Dali::WheelEvent *arg2 = 0 ;
64601   SwigDirector_ViewImpl *darg = 0;
64602   bool result;
64603
64604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64605   arg2 = (Dali::WheelEvent *)jarg2;
64606   if (!arg2) {
64607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64608     return 0;
64609   }
64610   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64611   if (!darg) {
64612     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64613     return 0;
64614   }
64615   {
64616     try {
64617       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64618     } catch (std::out_of_range& e) {
64619       {
64620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64621       };
64622     } catch (std::exception& e) {
64623       {
64624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64625       };
64626     } catch (Dali::DaliException e) {
64627       {
64628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64629       };
64630     } catch (...) {
64631       {
64632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64633       };
64634     }
64635   }
64636
64637   jresult = result;
64638   return jresult;
64639 }
64640
64641
64642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64643   unsigned int jresult ;
64644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64645   Dali::WheelEvent *arg2 = 0 ;
64646   SwigDirector_ViewImpl *darg = 0;
64647   bool result;
64648
64649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64650   arg2 = (Dali::WheelEvent *)jarg2;
64651   if (!arg2) {
64652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64653     return 0;
64654   }
64655   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64656   if (!darg) {
64657     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64658     return 0;
64659   }
64660   {
64661     try {
64662       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64663     } catch (std::out_of_range& e) {
64664       {
64665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64666       };
64667     } catch (std::exception& e) {
64668       {
64669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64670       };
64671     } catch (Dali::DaliException e) {
64672       {
64673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64674       };
64675     } catch (...) {
64676       {
64677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64678       };
64679     }
64680   }
64681
64682   jresult = result;
64683   return jresult;
64684 }
64685
64686
64687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(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)->OnRelayout((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_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64735   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64736   Dali::Vector2 *arg2 = 0 ;
64737   Dali::RelayoutContainer *arg3 = 0 ;
64738   SwigDirector_ViewImpl *darg = 0;
64739
64740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64741   arg2 = (Dali::Vector2 *)jarg2;
64742   if (!arg2) {
64743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64744     return ;
64745   }
64746   arg3 = (Dali::RelayoutContainer *)jarg3;
64747   if (!arg3) {
64748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64749     return ;
64750   }
64751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64752   if (!darg) {
64753     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64754     return;
64755   }
64756   {
64757     try {
64758       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64759     } catch (std::out_of_range& e) {
64760       {
64761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64762       };
64763     } catch (std::exception& e) {
64764       {
64765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64766       };
64767     } catch (Dali::DaliException e) {
64768       {
64769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64770       };
64771     } catch (...) {
64772       {
64773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64774       };
64775     }
64776   }
64777
64778 }
64779
64780
64781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64782   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64783   Dali::ResizePolicy::Type arg2 ;
64784   Dali::Dimension::Type arg3 ;
64785   SwigDirector_ViewImpl *darg = 0;
64786
64787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64788   arg2 = (Dali::ResizePolicy::Type)jarg2;
64789   arg3 = (Dali::Dimension::Type)jarg3;
64790   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64791   if (!darg) {
64792     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64793     return;
64794   }
64795   {
64796     try {
64797       (darg)->OnSetResizePolicy(arg2,arg3);
64798     } catch (std::out_of_range& e) {
64799       {
64800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64801       };
64802     } catch (std::exception& e) {
64803       {
64804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64805       };
64806     } catch (Dali::DaliException e) {
64807       {
64808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64809       };
64810     } catch (...) {
64811       {
64812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64813       };
64814     }
64815   }
64816
64817 }
64818
64819
64820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64822   Dali::ResizePolicy::Type arg2 ;
64823   Dali::Dimension::Type arg3 ;
64824   SwigDirector_ViewImpl *darg = 0;
64825
64826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64827   arg2 = (Dali::ResizePolicy::Type)jarg2;
64828   arg3 = (Dali::Dimension::Type)jarg3;
64829   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64830   if (!darg) {
64831     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64832     return;
64833   }
64834   {
64835     try {
64836       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64837     } catch (std::out_of_range& e) {
64838       {
64839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64840       };
64841     } catch (std::exception& e) {
64842       {
64843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64844       };
64845     } catch (Dali::DaliException e) {
64846       {
64847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64848       };
64849     } catch (...) {
64850       {
64851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64852       };
64853     }
64854   }
64855
64856 }
64857
64858
64859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64860   void * jresult ;
64861   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64862   SwigDirector_ViewImpl *darg = 0;
64863   Dali::Vector3 result;
64864
64865   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64866   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64867   if (!darg) {
64868     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64869     return 0;
64870   }
64871   {
64872     try {
64873       result = (darg)->GetNaturalSize();
64874     } catch (std::out_of_range& e) {
64875       {
64876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64877       };
64878     } catch (std::exception& e) {
64879       {
64880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64881       };
64882     } catch (Dali::DaliException e) {
64883       {
64884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64885       };
64886     } catch (...) {
64887       {
64888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64889       };
64890     }
64891   }
64892
64893   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64894   return jresult;
64895 }
64896
64897
64898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64899   void * jresult ;
64900   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64901   SwigDirector_ViewImpl *darg = 0;
64902   Dali::Vector3 result;
64903
64904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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 = (darg)->GetNaturalSizeSwigPublic();
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 = new Dali::Vector3((const Dali::Vector3 &)result);
64933   return jresult;
64934 }
64935
64936
64937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(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)->CalculateChildSize((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_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64985   float jresult ;
64986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64987   Dali::Actor *arg2 = 0 ;
64988   Dali::Dimension::Type arg3 ;
64989   SwigDirector_ViewImpl *darg = 0;
64990   float result;
64991
64992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64993   arg2 = (Dali::Actor *)jarg2;
64994   if (!arg2) {
64995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64996     return 0;
64997   }
64998   arg3 = (Dali::Dimension::Type)jarg3;
64999   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65000   if (!darg) {
65001     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65002     return 0;
65003   }
65004   {
65005     try {
65006       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65007     } catch (std::out_of_range& e) {
65008       {
65009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65010       };
65011     } catch (std::exception& e) {
65012       {
65013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65014       };
65015     } catch (Dali::DaliException e) {
65016       {
65017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65018       };
65019     } catch (...) {
65020       {
65021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65022       };
65023     }
65024   }
65025
65026   jresult = result;
65027   return jresult;
65028 }
65029
65030
65031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65032   float jresult ;
65033   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65034   float arg2 ;
65035   SwigDirector_ViewImpl *darg = 0;
65036   float result;
65037
65038   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65039   arg2 = (float)jarg2;
65040   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65041   if (!darg) {
65042     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65043     return 0;
65044   }
65045   {
65046     try {
65047       result = (float)(darg)->GetHeightForWidth(arg2);
65048     } catch (std::out_of_range& e) {
65049       {
65050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65051       };
65052     } catch (std::exception& e) {
65053       {
65054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65055       };
65056     } catch (Dali::DaliException e) {
65057       {
65058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65059       };
65060     } catch (...) {
65061       {
65062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65063       };
65064     }
65065   }
65066
65067   jresult = result;
65068   return jresult;
65069 }
65070
65071
65072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65073   float jresult ;
65074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65075   float arg2 ;
65076   SwigDirector_ViewImpl *darg = 0;
65077   float result;
65078
65079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65080   arg2 = (float)jarg2;
65081   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65082   if (!darg) {
65083     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65084     return 0;
65085   }
65086   {
65087     try {
65088       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65089     } catch (std::out_of_range& e) {
65090       {
65091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65092       };
65093     } catch (std::exception& e) {
65094       {
65095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65096       };
65097     } catch (Dali::DaliException e) {
65098       {
65099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65100       };
65101     } catch (...) {
65102       {
65103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65104       };
65105     }
65106   }
65107
65108   jresult = result;
65109   return jresult;
65110 }
65111
65112
65113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65114   float jresult ;
65115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65116   float arg2 ;
65117   SwigDirector_ViewImpl *darg = 0;
65118   float result;
65119
65120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65121   arg2 = (float)jarg2;
65122   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65123   if (!darg) {
65124     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65125     return 0;
65126   }
65127   {
65128     try {
65129       result = (float)(darg)->GetWidthForHeight(arg2);
65130     } catch (std::out_of_range& e) {
65131       {
65132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65133       };
65134     } catch (std::exception& e) {
65135       {
65136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65137       };
65138     } catch (Dali::DaliException e) {
65139       {
65140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65141       };
65142     } catch (...) {
65143       {
65144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65145       };
65146     }
65147   }
65148
65149   jresult = result;
65150   return jresult;
65151 }
65152
65153
65154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65155   float jresult ;
65156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65157   float arg2 ;
65158   SwigDirector_ViewImpl *darg = 0;
65159   float result;
65160
65161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65162   arg2 = (float)jarg2;
65163   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65164   if (!darg) {
65165     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65166     return 0;
65167   }
65168   {
65169     try {
65170       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65171     } catch (std::out_of_range& e) {
65172       {
65173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65174       };
65175     } catch (std::exception& e) {
65176       {
65177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65178       };
65179     } catch (Dali::DaliException e) {
65180       {
65181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65182       };
65183     } catch (...) {
65184       {
65185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65186       };
65187     }
65188   }
65189
65190   jresult = result;
65191   return jresult;
65192 }
65193
65194
65195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65196   unsigned int jresult ;
65197   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65198   Dali::Dimension::Type arg2 ;
65199   SwigDirector_ViewImpl *darg = 0;
65200   bool result;
65201
65202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65203   arg2 = (Dali::Dimension::Type)jarg2;
65204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65205   if (!darg) {
65206     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65207     return 0;
65208   }
65209   {
65210     try {
65211       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65212     } catch (std::out_of_range& e) {
65213       {
65214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65215       };
65216     } catch (std::exception& e) {
65217       {
65218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65219       };
65220     } catch (Dali::DaliException e) {
65221       {
65222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65223       };
65224     } catch (...) {
65225       {
65226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65227       };
65228     }
65229   }
65230
65231   jresult = result;
65232   return jresult;
65233 }
65234
65235
65236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65237   unsigned int jresult ;
65238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65239   Dali::Dimension::Type arg2 ;
65240   SwigDirector_ViewImpl *darg = 0;
65241   bool result;
65242
65243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65244   arg2 = (Dali::Dimension::Type)jarg2;
65245   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65246   if (!darg) {
65247     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65248     return 0;
65249   }
65250   {
65251     try {
65252       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65253     } catch (std::out_of_range& e) {
65254       {
65255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65256       };
65257     } catch (std::exception& e) {
65258       {
65259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65260       };
65261     } catch (Dali::DaliException e) {
65262       {
65263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65264       };
65265     } catch (...) {
65266       {
65267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65268       };
65269     }
65270   }
65271
65272   jresult = result;
65273   return jresult;
65274 }
65275
65276
65277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65278   unsigned int jresult ;
65279   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65280   SwigDirector_ViewImpl *darg = 0;
65281   bool result;
65282
65283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65284   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65285   if (!darg) {
65286     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65287     return 0;
65288   }
65289   {
65290     try {
65291       result = (bool)(darg)->RelayoutDependentOnChildren();
65292     } catch (std::out_of_range& e) {
65293       {
65294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65295       };
65296     } catch (std::exception& e) {
65297       {
65298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65299       };
65300     } catch (Dali::DaliException e) {
65301       {
65302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65303       };
65304     } catch (...) {
65305       {
65306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65307       };
65308     }
65309   }
65310
65311   jresult = result;
65312   return jresult;
65313 }
65314
65315
65316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65317   unsigned int jresult ;
65318   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65319   SwigDirector_ViewImpl *darg = 0;
65320   bool result;
65321
65322   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65323   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65324   if (!darg) {
65325     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65326     return 0;
65327   }
65328   {
65329     try {
65330       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65331     } catch (std::out_of_range& e) {
65332       {
65333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65334       };
65335     } catch (std::exception& e) {
65336       {
65337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65338       };
65339     } catch (Dali::DaliException e) {
65340       {
65341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65342       };
65343     } catch (...) {
65344       {
65345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65346       };
65347     }
65348   }
65349
65350   jresult = result;
65351   return jresult;
65352 }
65353
65354
65355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65357   Dali::Dimension::Type arg2 ;
65358   SwigDirector_ViewImpl *darg = 0;
65359
65360   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65361   arg2 = (Dali::Dimension::Type)jarg2;
65362   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65363   if (!darg) {
65364     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65365     return;
65366   }
65367   {
65368     try {
65369       (darg)->OnCalculateRelayoutSize(arg2);
65370     } catch (std::out_of_range& e) {
65371       {
65372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65373       };
65374     } catch (std::exception& e) {
65375       {
65376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65377       };
65378     } catch (Dali::DaliException e) {
65379       {
65380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65381       };
65382     } catch (...) {
65383       {
65384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65385       };
65386     }
65387   }
65388
65389 }
65390
65391
65392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65393   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65394   Dali::Dimension::Type arg2 ;
65395   SwigDirector_ViewImpl *darg = 0;
65396
65397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65398   arg2 = (Dali::Dimension::Type)jarg2;
65399   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65400   if (!darg) {
65401     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65402     return;
65403   }
65404   {
65405     try {
65406       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65407     } catch (std::out_of_range& e) {
65408       {
65409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65410       };
65411     } catch (std::exception& e) {
65412       {
65413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65414       };
65415     } catch (Dali::DaliException e) {
65416       {
65417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65418       };
65419     } catch (...) {
65420       {
65421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65422       };
65423     }
65424   }
65425
65426 }
65427
65428
65429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65431   float arg2 ;
65432   Dali::Dimension::Type arg3 ;
65433   SwigDirector_ViewImpl *darg = 0;
65434
65435   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65436   arg2 = (float)jarg2;
65437   arg3 = (Dali::Dimension::Type)jarg3;
65438   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65439   if (!darg) {
65440     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65441     return;
65442   }
65443   {
65444     try {
65445       (darg)->OnLayoutNegotiated(arg2,arg3);
65446     } catch (std::out_of_range& e) {
65447       {
65448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65449       };
65450     } catch (std::exception& e) {
65451       {
65452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65453       };
65454     } catch (Dali::DaliException e) {
65455       {
65456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65457       };
65458     } catch (...) {
65459       {
65460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65461       };
65462     }
65463   }
65464
65465 }
65466
65467
65468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65470   float arg2 ;
65471   Dali::Dimension::Type arg3 ;
65472   SwigDirector_ViewImpl *darg = 0;
65473
65474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65475   arg2 = (float)jarg2;
65476   arg3 = (Dali::Dimension::Type)jarg3;
65477   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65478   if (!darg) {
65479     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65480     return;
65481   }
65482   {
65483     try {
65484       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65485     } catch (std::out_of_range& e) {
65486       {
65487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65488       };
65489     } catch (std::exception& e) {
65490       {
65491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65492       };
65493     } catch (Dali::DaliException e) {
65494       {
65495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65496       };
65497     } catch (...) {
65498       {
65499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65500       };
65501     }
65502   }
65503
65504 }
65505
65506
65507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65509
65510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65511   {
65512     try {
65513       (arg1)->OnInitialize();
65514     } catch (std::out_of_range& e) {
65515       {
65516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65517       };
65518     } catch (std::exception& e) {
65519       {
65520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65521       };
65522     } catch (Dali::DaliException e) {
65523       {
65524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65525       };
65526     } catch (...) {
65527       {
65528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65529       };
65530     }
65531   }
65532
65533 }
65534
65535
65536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65538
65539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65540   {
65541     try {
65542       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65543     } catch (std::out_of_range& e) {
65544       {
65545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65546       };
65547     } catch (std::exception& e) {
65548       {
65549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65550       };
65551     } catch (Dali::DaliException e) {
65552       {
65553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65554       };
65555     } catch (...) {
65556       {
65557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65558       };
65559     }
65560   }
65561
65562 }
65563
65564
65565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65567   Dali::Actor *arg2 = 0 ;
65568
65569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65570   arg2 = (Dali::Actor *)jarg2;
65571   if (!arg2) {
65572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65573     return ;
65574   }
65575   {
65576     try {
65577       (arg1)->OnControlChildAdd(*arg2);
65578     } catch (std::out_of_range& e) {
65579       {
65580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65581       };
65582     } catch (std::exception& e) {
65583       {
65584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65585       };
65586     } catch (Dali::DaliException e) {
65587       {
65588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65589       };
65590     } catch (...) {
65591       {
65592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65593       };
65594     }
65595   }
65596
65597 }
65598
65599
65600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65602   Dali::Actor *arg2 = 0 ;
65603
65604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65605   arg2 = (Dali::Actor *)jarg2;
65606   if (!arg2) {
65607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65608     return ;
65609   }
65610   {
65611     try {
65612       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65613     } catch (std::out_of_range& e) {
65614       {
65615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65616       };
65617     } catch (std::exception& e) {
65618       {
65619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65620       };
65621     } catch (Dali::DaliException e) {
65622       {
65623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65624       };
65625     } catch (...) {
65626       {
65627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65628       };
65629     }
65630   }
65631
65632 }
65633
65634
65635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65637   Dali::Actor *arg2 = 0 ;
65638
65639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65640   arg2 = (Dali::Actor *)jarg2;
65641   if (!arg2) {
65642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65643     return ;
65644   }
65645   {
65646     try {
65647       (arg1)->OnControlChildRemove(*arg2);
65648     } catch (std::out_of_range& e) {
65649       {
65650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65651       };
65652     } catch (std::exception& e) {
65653       {
65654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65655       };
65656     } catch (Dali::DaliException e) {
65657       {
65658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65659       };
65660     } catch (...) {
65661       {
65662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65663       };
65664     }
65665   }
65666
65667 }
65668
65669
65670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65672   Dali::Actor *arg2 = 0 ;
65673
65674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65675   arg2 = (Dali::Actor *)jarg2;
65676   if (!arg2) {
65677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65678     return ;
65679   }
65680   {
65681     try {
65682       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65683     } catch (std::out_of_range& e) {
65684       {
65685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65686       };
65687     } catch (std::exception& e) {
65688       {
65689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65690       };
65691     } catch (Dali::DaliException e) {
65692       {
65693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65694       };
65695     } catch (...) {
65696       {
65697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65698       };
65699     }
65700   }
65701
65702 }
65703
65704
65705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65707   Dali::Toolkit::StyleManager arg2 ;
65708   Dali::StyleChange::Type arg3 ;
65709   Dali::Toolkit::StyleManager *argp2 ;
65710
65711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65712   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65713   if (!argp2) {
65714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65715     return ;
65716   }
65717   arg2 = *argp2;
65718   arg3 = (Dali::StyleChange::Type)jarg3;
65719   {
65720     try {
65721       (arg1)->OnStyleChange(arg2,arg3);
65722     } catch (std::out_of_range& e) {
65723       {
65724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65725       };
65726     } catch (std::exception& e) {
65727       {
65728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65729       };
65730     } catch (Dali::DaliException e) {
65731       {
65732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65733       };
65734     } catch (...) {
65735       {
65736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65737       };
65738     }
65739   }
65740
65741 }
65742
65743
65744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65746   Dali::Toolkit::StyleManager arg2 ;
65747   Dali::StyleChange::Type arg3 ;
65748   Dali::Toolkit::StyleManager *argp2 ;
65749
65750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65751   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65752   if (!argp2) {
65753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65754     return ;
65755   }
65756   arg2 = *argp2;
65757   arg3 = (Dali::StyleChange::Type)jarg3;
65758   {
65759     try {
65760       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65761     } catch (std::out_of_range& e) {
65762       {
65763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65764       };
65765     } catch (std::exception& e) {
65766       {
65767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65768       };
65769     } catch (Dali::DaliException e) {
65770       {
65771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65772       };
65773     } catch (...) {
65774       {
65775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65776       };
65777     }
65778   }
65779
65780 }
65781
65782
65783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65784   unsigned int jresult ;
65785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65786   bool result;
65787
65788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65789   {
65790     try {
65791       result = (bool)(arg1)->OnAccessibilityActivated();
65792     } catch (std::out_of_range& e) {
65793       {
65794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65795       };
65796     } catch (std::exception& e) {
65797       {
65798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65799       };
65800     } catch (Dali::DaliException e) {
65801       {
65802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65803       };
65804     } catch (...) {
65805       {
65806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65807       };
65808     }
65809   }
65810
65811   jresult = result;
65812   return jresult;
65813 }
65814
65815
65816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65817   unsigned int jresult ;
65818   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65819   bool result;
65820
65821   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65822   {
65823     try {
65824       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65825     } catch (std::out_of_range& e) {
65826       {
65827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65828       };
65829     } catch (std::exception& e) {
65830       {
65831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65832       };
65833     } catch (Dali::DaliException e) {
65834       {
65835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65836       };
65837     } catch (...) {
65838       {
65839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65840       };
65841     }
65842   }
65843
65844   jresult = result;
65845   return jresult;
65846 }
65847
65848
65849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65850   unsigned int jresult ;
65851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65852   Dali::PanGesture arg2 ;
65853   Dali::PanGesture *argp2 ;
65854   bool result;
65855
65856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65857   argp2 = (Dali::PanGesture *)jarg2;
65858   if (!argp2) {
65859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65860     return 0;
65861   }
65862   arg2 = *argp2;
65863   {
65864     try {
65865       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65866     } catch (std::out_of_range& e) {
65867       {
65868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65869       };
65870     } catch (std::exception& e) {
65871       {
65872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65873       };
65874     } catch (Dali::DaliException e) {
65875       {
65876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65877       };
65878     } catch (...) {
65879       {
65880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65881       };
65882     }
65883   }
65884
65885   jresult = result;
65886   return jresult;
65887 }
65888
65889
65890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65891   unsigned int jresult ;
65892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65893   Dali::PanGesture arg2 ;
65894   Dali::PanGesture *argp2 ;
65895   bool result;
65896
65897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65898   argp2 = (Dali::PanGesture *)jarg2;
65899   if (!argp2) {
65900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65901     return 0;
65902   }
65903   arg2 = *argp2;
65904   {
65905     try {
65906       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65907     } catch (std::out_of_range& e) {
65908       {
65909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65910       };
65911     } catch (std::exception& e) {
65912       {
65913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65914       };
65915     } catch (Dali::DaliException e) {
65916       {
65917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65918       };
65919     } catch (...) {
65920       {
65921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65922       };
65923     }
65924   }
65925
65926   jresult = result;
65927   return jresult;
65928 }
65929
65930
65931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65932   unsigned int jresult ;
65933   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65934   Dali::TouchEvent *arg2 = 0 ;
65935   bool result;
65936
65937   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65938   arg2 = (Dali::TouchEvent *)jarg2;
65939   if (!arg2) {
65940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65941     return 0;
65942   }
65943   {
65944     try {
65945       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65946     } catch (std::out_of_range& e) {
65947       {
65948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65949       };
65950     } catch (std::exception& e) {
65951       {
65952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65953       };
65954     } catch (Dali::DaliException e) {
65955       {
65956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65957       };
65958     } catch (...) {
65959       {
65960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65961       };
65962     }
65963   }
65964
65965   jresult = result;
65966   return jresult;
65967 }
65968
65969
65970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65971   unsigned int jresult ;
65972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65973   Dali::TouchEvent *arg2 = 0 ;
65974   bool result;
65975
65976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65977   arg2 = (Dali::TouchEvent *)jarg2;
65978   if (!arg2) {
65979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65980     return 0;
65981   }
65982   {
65983     try {
65984       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65985     } catch (std::out_of_range& e) {
65986       {
65987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65988       };
65989     } catch (std::exception& e) {
65990       {
65991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65992       };
65993     } catch (Dali::DaliException e) {
65994       {
65995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65996       };
65997     } catch (...) {
65998       {
65999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66000       };
66001     }
66002   }
66003
66004   jresult = result;
66005   return jresult;
66006 }
66007
66008
66009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66010   unsigned int jresult ;
66011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66012   bool arg2 ;
66013   bool result;
66014
66015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66016   arg2 = jarg2 ? true : false;
66017   {
66018     try {
66019       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66020     } catch (std::out_of_range& e) {
66021       {
66022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66023       };
66024     } catch (std::exception& e) {
66025       {
66026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66027       };
66028     } catch (Dali::DaliException e) {
66029       {
66030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66031       };
66032     } catch (...) {
66033       {
66034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66035       };
66036     }
66037   }
66038
66039   jresult = result;
66040   return jresult;
66041 }
66042
66043
66044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66045   unsigned int jresult ;
66046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66047   bool arg2 ;
66048   bool result;
66049
66050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66051   arg2 = jarg2 ? true : false;
66052   {
66053     try {
66054       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66055     } catch (std::out_of_range& e) {
66056       {
66057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66058       };
66059     } catch (std::exception& e) {
66060       {
66061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66062       };
66063     } catch (Dali::DaliException e) {
66064       {
66065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66066       };
66067     } catch (...) {
66068       {
66069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66070       };
66071     }
66072   }
66073
66074   jresult = result;
66075   return jresult;
66076 }
66077
66078
66079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66080   unsigned int jresult ;
66081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66082   bool result;
66083
66084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66085   {
66086     try {
66087       result = (bool)(arg1)->OnAccessibilityZoom();
66088     } catch (std::out_of_range& e) {
66089       {
66090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66091       };
66092     } catch (std::exception& e) {
66093       {
66094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66095       };
66096     } catch (Dali::DaliException e) {
66097       {
66098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66099       };
66100     } catch (...) {
66101       {
66102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66103       };
66104     }
66105   }
66106
66107   jresult = result;
66108   return jresult;
66109 }
66110
66111
66112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66113   unsigned int jresult ;
66114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66115   bool result;
66116
66117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66118   {
66119     try {
66120       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66121     } catch (std::out_of_range& e) {
66122       {
66123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66124       };
66125     } catch (std::exception& e) {
66126       {
66127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66128       };
66129     } catch (Dali::DaliException e) {
66130       {
66131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66132       };
66133     } catch (...) {
66134       {
66135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66136       };
66137     }
66138   }
66139
66140   jresult = result;
66141   return jresult;
66142 }
66143
66144
66145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66147
66148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66149   {
66150     try {
66151       (arg1)->OnKeyInputFocusGained();
66152     } catch (std::out_of_range& e) {
66153       {
66154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66155       };
66156     } catch (std::exception& e) {
66157       {
66158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66159       };
66160     } catch (Dali::DaliException e) {
66161       {
66162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66163       };
66164     } catch (...) {
66165       {
66166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66167       };
66168     }
66169   }
66170
66171 }
66172
66173
66174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66176
66177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66178   {
66179     try {
66180       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66181     } catch (std::out_of_range& e) {
66182       {
66183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66184       };
66185     } catch (std::exception& e) {
66186       {
66187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66188       };
66189     } catch (Dali::DaliException e) {
66190       {
66191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66192       };
66193     } catch (...) {
66194       {
66195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66196       };
66197     }
66198   }
66199
66200 }
66201
66202
66203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66205
66206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66207   {
66208     try {
66209       (arg1)->OnKeyInputFocusLost();
66210     } catch (std::out_of_range& e) {
66211       {
66212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66213       };
66214     } catch (std::exception& e) {
66215       {
66216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66217       };
66218     } catch (Dali::DaliException e) {
66219       {
66220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66221       };
66222     } catch (...) {
66223       {
66224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66225       };
66226     }
66227   }
66228
66229 }
66230
66231
66232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66234
66235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66236   {
66237     try {
66238       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66239     } catch (std::out_of_range& e) {
66240       {
66241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66242       };
66243     } catch (std::exception& e) {
66244       {
66245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66246       };
66247     } catch (Dali::DaliException e) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66250       };
66251     } catch (...) {
66252       {
66253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66254       };
66255     }
66256   }
66257
66258 }
66259
66260
66261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66262   void * jresult ;
66263   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66264   Dali::Actor arg2 ;
66265   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66266   bool arg4 ;
66267   Dali::Actor *argp2 ;
66268   Dali::Actor result;
66269
66270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66271   argp2 = (Dali::Actor *)jarg2;
66272   if (!argp2) {
66273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66274     return 0;
66275   }
66276   arg2 = *argp2;
66277   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66278   arg4 = jarg4 ? true : false;
66279   {
66280     try {
66281       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66282     } catch (std::out_of_range& e) {
66283       {
66284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66285       };
66286     } catch (std::exception& e) {
66287       {
66288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66289       };
66290     } catch (Dali::DaliException e) {
66291       {
66292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66293       };
66294     } catch (...) {
66295       {
66296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66297       };
66298     }
66299   }
66300
66301   jresult = new Dali::Actor((const Dali::Actor &)result);
66302   return jresult;
66303 }
66304
66305
66306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66307   void * jresult ;
66308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66309   Dali::Actor arg2 ;
66310   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66311   bool arg4 ;
66312   Dali::Actor *argp2 ;
66313   Dali::Actor result;
66314
66315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66316   argp2 = (Dali::Actor *)jarg2;
66317   if (!argp2) {
66318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66319     return 0;
66320   }
66321   arg2 = *argp2;
66322   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66323   arg4 = jarg4 ? true : false;
66324   {
66325     try {
66326       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66327     } catch (std::out_of_range& e) {
66328       {
66329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66330       };
66331     } catch (std::exception& e) {
66332       {
66333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66334       };
66335     } catch (Dali::DaliException e) {
66336       {
66337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66338       };
66339     } catch (...) {
66340       {
66341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66342       };
66343     }
66344   }
66345
66346   jresult = new Dali::Actor((const Dali::Actor &)result);
66347   return jresult;
66348 }
66349
66350
66351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66353   Dali::Actor arg2 ;
66354   Dali::Actor *argp2 ;
66355
66356   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66357   argp2 = (Dali::Actor *)jarg2;
66358   if (!argp2) {
66359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66360     return ;
66361   }
66362   arg2 = *argp2;
66363   {
66364     try {
66365       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66366     } catch (std::out_of_range& e) {
66367       {
66368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66369       };
66370     } catch (std::exception& e) {
66371       {
66372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66373       };
66374     } catch (Dali::DaliException e) {
66375       {
66376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66377       };
66378     } catch (...) {
66379       {
66380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66381       };
66382     }
66383   }
66384
66385 }
66386
66387
66388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66390   Dali::Actor arg2 ;
66391   Dali::Actor *argp2 ;
66392
66393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66394   argp2 = (Dali::Actor *)jarg2;
66395   if (!argp2) {
66396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66397     return ;
66398   }
66399   arg2 = *argp2;
66400   {
66401     try {
66402       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66403     } catch (std::out_of_range& e) {
66404       {
66405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66406       };
66407     } catch (std::exception& e) {
66408       {
66409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66410       };
66411     } catch (Dali::DaliException e) {
66412       {
66413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66414       };
66415     } catch (...) {
66416       {
66417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66418       };
66419     }
66420   }
66421
66422 }
66423
66424
66425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66426   unsigned int jresult ;
66427   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66428   bool result;
66429
66430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66431   {
66432     try {
66433       result = (bool)(arg1)->OnKeyboardEnter();
66434     } catch (std::out_of_range& e) {
66435       {
66436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66437       };
66438     } catch (std::exception& e) {
66439       {
66440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66441       };
66442     } catch (Dali::DaliException e) {
66443       {
66444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66445       };
66446     } catch (...) {
66447       {
66448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66449       };
66450     }
66451   }
66452
66453   jresult = result;
66454   return jresult;
66455 }
66456
66457
66458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66459   unsigned int jresult ;
66460   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66461   bool result;
66462
66463   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66464   {
66465     try {
66466       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66467     } catch (std::out_of_range& e) {
66468       {
66469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66470       };
66471     } catch (std::exception& e) {
66472       {
66473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66474       };
66475     } catch (Dali::DaliException e) {
66476       {
66477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66478       };
66479     } catch (...) {
66480       {
66481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66482       };
66483     }
66484   }
66485
66486   jresult = result;
66487   return jresult;
66488 }
66489
66490
66491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66492   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66493   Dali::PinchGesture *arg2 = 0 ;
66494
66495   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66496   arg2 = (Dali::PinchGesture *)jarg2;
66497   if (!arg2) {
66498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66499     return ;
66500   }
66501   {
66502     try {
66503       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66504     } catch (std::out_of_range& e) {
66505       {
66506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66507       };
66508     } catch (std::exception& e) {
66509       {
66510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66511       };
66512     } catch (Dali::DaliException e) {
66513       {
66514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66515       };
66516     } catch (...) {
66517       {
66518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66519       };
66520     }
66521   }
66522
66523 }
66524
66525
66526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66527   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66528   Dali::PinchGesture *arg2 = 0 ;
66529
66530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66531   arg2 = (Dali::PinchGesture *)jarg2;
66532   if (!arg2) {
66533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66534     return ;
66535   }
66536   {
66537     try {
66538       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66539     } catch (std::out_of_range& e) {
66540       {
66541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66542       };
66543     } catch (std::exception& e) {
66544       {
66545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66546       };
66547     } catch (Dali::DaliException e) {
66548       {
66549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66550       };
66551     } catch (...) {
66552       {
66553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66554       };
66555     }
66556   }
66557
66558 }
66559
66560
66561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66563   Dali::PanGesture *arg2 = 0 ;
66564
66565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66566   arg2 = (Dali::PanGesture *)jarg2;
66567   if (!arg2) {
66568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66569     return ;
66570   }
66571   {
66572     try {
66573       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66574     } catch (std::out_of_range& e) {
66575       {
66576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66577       };
66578     } catch (std::exception& e) {
66579       {
66580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66581       };
66582     } catch (Dali::DaliException e) {
66583       {
66584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66585       };
66586     } catch (...) {
66587       {
66588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66589       };
66590     }
66591   }
66592
66593 }
66594
66595
66596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66598   Dali::PanGesture *arg2 = 0 ;
66599
66600   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66601   arg2 = (Dali::PanGesture *)jarg2;
66602   if (!arg2) {
66603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66604     return ;
66605   }
66606   {
66607     try {
66608       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66609     } catch (std::out_of_range& e) {
66610       {
66611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66612       };
66613     } catch (std::exception& e) {
66614       {
66615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66616       };
66617     } catch (Dali::DaliException e) {
66618       {
66619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66620       };
66621     } catch (...) {
66622       {
66623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66624       };
66625     }
66626   }
66627
66628 }
66629
66630
66631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66633   Dali::TapGesture *arg2 = 0 ;
66634
66635   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66636   arg2 = (Dali::TapGesture *)jarg2;
66637   if (!arg2) {
66638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66639     return ;
66640   }
66641   {
66642     try {
66643       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66644     } catch (std::out_of_range& e) {
66645       {
66646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66647       };
66648     } catch (std::exception& e) {
66649       {
66650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66651       };
66652     } catch (Dali::DaliException e) {
66653       {
66654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66655       };
66656     } catch (...) {
66657       {
66658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66659       };
66660     }
66661   }
66662
66663 }
66664
66665
66666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66668   Dali::TapGesture *arg2 = 0 ;
66669
66670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66671   arg2 = (Dali::TapGesture *)jarg2;
66672   if (!arg2) {
66673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66674     return ;
66675   }
66676   {
66677     try {
66678       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66679     } catch (std::out_of_range& e) {
66680       {
66681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66682       };
66683     } catch (std::exception& e) {
66684       {
66685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66686       };
66687     } catch (Dali::DaliException e) {
66688       {
66689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66690       };
66691     } catch (...) {
66692       {
66693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66694       };
66695     }
66696   }
66697
66698 }
66699
66700
66701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66703   Dali::LongPressGesture *arg2 = 0 ;
66704
66705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66706   arg2 = (Dali::LongPressGesture *)jarg2;
66707   if (!arg2) {
66708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66709     return ;
66710   }
66711   {
66712     try {
66713       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66721       };
66722     } catch (Dali::DaliException e) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66725       };
66726     } catch (...) {
66727       {
66728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66729       };
66730     }
66731   }
66732
66733 }
66734
66735
66736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66738   Dali::LongPressGesture *arg2 = 0 ;
66739
66740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66741   arg2 = (Dali::LongPressGesture *)jarg2;
66742   if (!arg2) {
66743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66744     return ;
66745   }
66746   {
66747     try {
66748       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66749     } catch (std::out_of_range& e) {
66750       {
66751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66752       };
66753     } catch (std::exception& e) {
66754       {
66755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66756       };
66757     } catch (Dali::DaliException e) {
66758       {
66759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66760       };
66761     } catch (...) {
66762       {
66763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66764       };
66765     }
66766   }
66767
66768 }
66769
66770
66771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66773   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66774   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66775
66776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66777   arg2 = (Dali::SlotObserver *)jarg2;
66778   arg3 = (Dali::CallbackBase *)jarg3;
66779   {
66780     try {
66781       (arg1)->SignalConnected(arg2,arg3);
66782     } catch (std::out_of_range& e) {
66783       {
66784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66785       };
66786     } catch (std::exception& e) {
66787       {
66788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66789       };
66790     } catch (Dali::DaliException e) {
66791       {
66792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66793       };
66794     } catch (...) {
66795       {
66796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66797       };
66798     }
66799   }
66800
66801 }
66802
66803
66804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66806   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66807   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66808
66809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66810   arg2 = (Dali::SlotObserver *)jarg2;
66811   arg3 = (Dali::CallbackBase *)jarg3;
66812   {
66813     try {
66814       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66815     } catch (std::out_of_range& e) {
66816       {
66817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66818       };
66819     } catch (std::exception& e) {
66820       {
66821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66822       };
66823     } catch (Dali::DaliException e) {
66824       {
66825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66826       };
66827     } catch (...) {
66828       {
66829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66830       };
66831     }
66832   }
66833
66834 }
66835
66836
66837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66839   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66840   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66841
66842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66843   arg2 = (Dali::SlotObserver *)jarg2;
66844   arg3 = (Dali::CallbackBase *)jarg3;
66845   {
66846     try {
66847       (arg1)->SignalDisconnected(arg2,arg3);
66848     } catch (std::out_of_range& e) {
66849       {
66850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66851       };
66852     } catch (std::exception& e) {
66853       {
66854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66855       };
66856     } catch (Dali::DaliException e) {
66857       {
66858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66859       };
66860     } catch (...) {
66861       {
66862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66863       };
66864     }
66865   }
66866
66867 }
66868
66869
66870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66872   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66873   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66874
66875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66876   arg2 = (Dali::SlotObserver *)jarg2;
66877   arg3 = (Dali::CallbackBase *)jarg3;
66878   {
66879     try {
66880       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66881     } catch (std::out_of_range& e) {
66882       {
66883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66884       };
66885     } catch (std::exception& e) {
66886       {
66887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66888       };
66889     } catch (Dali::DaliException e) {
66890       {
66891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66892       };
66893     } catch (...) {
66894       {
66895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66896       };
66897     }
66898   }
66899
66900 }
66901
66902
66903 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) {
66904   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66905   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66906   if (director) {
66907     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);
66908   }
66909 }
66910
66911
66912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66913   void * jresult ;
66914   Dali::Toolkit::Control *arg1 = 0 ;
66915   Dali::Toolkit::Internal::Control *result = 0 ;
66916
66917   arg1 = (Dali::Toolkit::Control *)jarg1;
66918   if (!arg1) {
66919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66920     return 0;
66921   }
66922   {
66923     try {
66924       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66925     } catch (std::out_of_range& e) {
66926       {
66927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66928       };
66929     } catch (std::exception& e) {
66930       {
66931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66932       };
66933     } catch (Dali::DaliException e) {
66934       {
66935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66936       };
66937     } catch (...) {
66938       {
66939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66940       };
66941     }
66942   }
66943
66944   jresult = (void *)result;
66945   return jresult;
66946 }
66947
66948
66949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66950   int jresult ;
66951   int result;
66952
66953   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66954   jresult = (int)result;
66955   return jresult;
66956 }
66957
66958
66959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
66960   int jresult ;
66961   int result;
66962
66963   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
66964   jresult = (int)result;
66965   return jresult;
66966 }
66967
66968
66969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
66970   int jresult ;
66971   int result;
66972
66973   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
66974   jresult = (int)result;
66975   return jresult;
66976 }
66977
66978
66979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66980   int jresult ;
66981   int result;
66982
66983   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66984   jresult = (int)result;
66985   return jresult;
66986 }
66987
66988
66989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66990   int jresult ;
66991   int result;
66992
66993   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66994   jresult = (int)result;
66995   return jresult;
66996 }
66997
66998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66999   int jresult ;
67000   int result;
67001
67002   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67003   jresult = (int)result;
67004   return jresult;
67005 }
67006
67007
67008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67009   int jresult ;
67010   int result;
67011
67012   result = (int)Dali::Toolkit::Control::Property::PADDING;
67013   jresult = (int)result;
67014   return jresult;
67015 }
67016
67017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67018   void * jresult ;
67019   Dali::Toolkit::Control::Property *result = 0 ;
67020
67021   {
67022     try {
67023       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67024     } catch (std::out_of_range& e) {
67025       {
67026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67027       };
67028     } catch (std::exception& e) {
67029       {
67030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67031       };
67032     } catch (Dali::DaliException e) {
67033       {
67034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67035       };
67036     } catch (...) {
67037       {
67038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67039       };
67040     }
67041   }
67042
67043   jresult = (void *)result;
67044   return jresult;
67045 }
67046
67047
67048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67049   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67050
67051   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67052   {
67053     try {
67054       delete arg1;
67055     } catch (std::out_of_range& e) {
67056       {
67057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67058       };
67059     } catch (std::exception& e) {
67060       {
67061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67062       };
67063     } catch (Dali::DaliException e) {
67064       {
67065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67066       };
67067     } catch (...) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67070       };
67071     }
67072   }
67073
67074 }
67075
67076
67077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67078   void * jresult ;
67079   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67080
67081   {
67082     try {
67083       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67084     } catch (std::out_of_range& e) {
67085       {
67086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67087       };
67088     } catch (std::exception& e) {
67089       {
67090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67091       };
67092     } catch (Dali::DaliException e) {
67093       {
67094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67095       };
67096     } catch (...) {
67097       {
67098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67099       };
67100     }
67101   }
67102
67103   jresult = (void *)result;
67104   return jresult;
67105 }
67106
67107
67108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67109   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67110
67111   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67112   {
67113     try {
67114       delete arg1;
67115     } catch (std::out_of_range& e) {
67116       {
67117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67118       };
67119     } catch (std::exception& e) {
67120       {
67121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67122       };
67123     } catch (Dali::DaliException e) {
67124       {
67125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67126       };
67127     } catch (...) {
67128       {
67129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67130       };
67131     }
67132   }
67133
67134 }
67135
67136
67137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67138   void * jresult ;
67139   Dali::Toolkit::Control result;
67140
67141   {
67142     try {
67143       result = Dali::Toolkit::Control::New();
67144     } catch (std::out_of_range& e) {
67145       {
67146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67147       };
67148     } catch (std::exception& e) {
67149       {
67150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67151       };
67152     } catch (Dali::DaliException e) {
67153       {
67154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67155       };
67156     } catch (...) {
67157       {
67158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67159       };
67160     }
67161   }
67162
67163   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67164   return jresult;
67165 }
67166
67167
67168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67169   void * jresult ;
67170   Dali::Toolkit::Control *result = 0 ;
67171
67172   {
67173     try {
67174       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67175     } catch (std::out_of_range& e) {
67176       {
67177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67178       };
67179     } catch (std::exception& e) {
67180       {
67181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67182       };
67183     } catch (Dali::DaliException e) {
67184       {
67185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67186       };
67187     } catch (...) {
67188       {
67189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67190       };
67191     }
67192   }
67193
67194   jresult = (void *)result;
67195   return jresult;
67196 }
67197
67198
67199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67200   void * jresult ;
67201   Dali::Toolkit::Control *arg1 = 0 ;
67202   Dali::Toolkit::Control *result = 0 ;
67203
67204   arg1 = (Dali::Toolkit::Control *)jarg1;
67205   if (!arg1) {
67206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67207     return 0;
67208   }
67209   {
67210     try {
67211       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67212     } catch (std::out_of_range& e) {
67213       {
67214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67215       };
67216     } catch (std::exception& e) {
67217       {
67218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67219       };
67220     } catch (Dali::DaliException e) {
67221       {
67222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67223       };
67224     } catch (...) {
67225       {
67226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67227       };
67228     }
67229   }
67230
67231   jresult = (void *)result;
67232   return jresult;
67233 }
67234
67235
67236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67237   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67238
67239   arg1 = (Dali::Toolkit::Control *)jarg1;
67240   {
67241     try {
67242       delete arg1;
67243     } catch (std::out_of_range& e) {
67244       {
67245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67246       };
67247     } catch (std::exception& e) {
67248       {
67249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67250       };
67251     } catch (Dali::DaliException e) {
67252       {
67253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67254       };
67255     } catch (...) {
67256       {
67257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67258       };
67259     }
67260   }
67261
67262 }
67263
67264
67265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67266   void * jresult ;
67267   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67268   Dali::Toolkit::Control *arg2 = 0 ;
67269   Dali::Toolkit::Control *result = 0 ;
67270
67271   arg1 = (Dali::Toolkit::Control *)jarg1;
67272   arg2 = (Dali::Toolkit::Control *)jarg2;
67273   if (!arg2) {
67274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67275     return 0;
67276   }
67277   {
67278     try {
67279       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67280     } catch (std::out_of_range& e) {
67281       {
67282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67283       };
67284     } catch (std::exception& e) {
67285       {
67286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67287       };
67288     } catch (Dali::DaliException e) {
67289       {
67290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67291       };
67292     } catch (...) {
67293       {
67294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67295       };
67296     }
67297   }
67298
67299   jresult = (void *)result;
67300   return jresult;
67301 }
67302
67303
67304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67305   void * jresult ;
67306   Dali::BaseHandle arg1 ;
67307   Dali::BaseHandle *argp1 ;
67308   Dali::Toolkit::Control result;
67309
67310   argp1 = (Dali::BaseHandle *)jarg1;
67311   if (!argp1) {
67312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67313     return 0;
67314   }
67315   arg1 = *argp1;
67316   {
67317     try {
67318       result = Dali::Toolkit::Control::DownCast(arg1);
67319     } catch (std::out_of_range& e) {
67320       {
67321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67322       };
67323     } catch (std::exception& e) {
67324       {
67325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67326       };
67327     } catch (Dali::DaliException e) {
67328       {
67329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67330       };
67331     } catch (...) {
67332       {
67333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67334       };
67335     }
67336   }
67337
67338   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67339   return jresult;
67340 }
67341
67342
67343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67344   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67345
67346   arg1 = (Dali::Toolkit::Control *)jarg1;
67347   {
67348     try {
67349       (arg1)->SetKeyInputFocus();
67350     } catch (std::out_of_range& e) {
67351       {
67352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67353       };
67354     } catch (std::exception& e) {
67355       {
67356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67357       };
67358     } catch (Dali::DaliException e) {
67359       {
67360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67361       };
67362     } catch (...) {
67363       {
67364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67365       };
67366     }
67367   }
67368
67369 }
67370
67371
67372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67373   unsigned int jresult ;
67374   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67375   bool result;
67376
67377   arg1 = (Dali::Toolkit::Control *)jarg1;
67378   {
67379     try {
67380       result = (bool)(arg1)->HasKeyInputFocus();
67381     } catch (std::out_of_range& e) {
67382       {
67383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67384       };
67385     } catch (std::exception& e) {
67386       {
67387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67388       };
67389     } catch (Dali::DaliException e) {
67390       {
67391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67392       };
67393     } catch (...) {
67394       {
67395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67396       };
67397     }
67398   }
67399
67400   jresult = result;
67401   return jresult;
67402 }
67403
67404
67405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67406   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67407
67408   arg1 = (Dali::Toolkit::Control *)jarg1;
67409   {
67410     try {
67411       (arg1)->ClearKeyInputFocus();
67412     } catch (std::out_of_range& e) {
67413       {
67414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67415       };
67416     } catch (std::exception& e) {
67417       {
67418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67419       };
67420     } catch (Dali::DaliException e) {
67421       {
67422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67423       };
67424     } catch (...) {
67425       {
67426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67427       };
67428     }
67429   }
67430
67431 }
67432
67433
67434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67435   void * jresult ;
67436   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67437   Dali::PinchGestureDetector result;
67438
67439   arg1 = (Dali::Toolkit::Control *)jarg1;
67440   {
67441     try {
67442       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67443     } catch (std::out_of_range& e) {
67444       {
67445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67446       };
67447     } catch (std::exception& e) {
67448       {
67449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67450       };
67451     } catch (Dali::DaliException e) {
67452       {
67453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67454       };
67455     } catch (...) {
67456       {
67457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67458       };
67459     }
67460   }
67461
67462   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67463   return jresult;
67464 }
67465
67466
67467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67468   void * jresult ;
67469   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67470   Dali::PanGestureDetector result;
67471
67472   arg1 = (Dali::Toolkit::Control *)jarg1;
67473   {
67474     try {
67475       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67476     } catch (std::out_of_range& e) {
67477       {
67478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67479       };
67480     } catch (std::exception& e) {
67481       {
67482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67483       };
67484     } catch (Dali::DaliException e) {
67485       {
67486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67487       };
67488     } catch (...) {
67489       {
67490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67491       };
67492     }
67493   }
67494
67495   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67496   return jresult;
67497 }
67498
67499
67500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67501   void * jresult ;
67502   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67503   Dali::TapGestureDetector result;
67504
67505   arg1 = (Dali::Toolkit::Control *)jarg1;
67506   {
67507     try {
67508       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67509     } catch (std::out_of_range& e) {
67510       {
67511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67512       };
67513     } catch (std::exception& e) {
67514       {
67515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67516       };
67517     } catch (Dali::DaliException e) {
67518       {
67519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67520       };
67521     } catch (...) {
67522       {
67523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67524       };
67525     }
67526   }
67527
67528   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67529   return jresult;
67530 }
67531
67532
67533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67534   void * jresult ;
67535   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67536   Dali::LongPressGestureDetector result;
67537
67538   arg1 = (Dali::Toolkit::Control *)jarg1;
67539   {
67540     try {
67541       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67542     } catch (std::out_of_range& e) {
67543       {
67544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67545       };
67546     } catch (std::exception& e) {
67547       {
67548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67549       };
67550     } catch (Dali::DaliException e) {
67551       {
67552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67553       };
67554     } catch (...) {
67555       {
67556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67557       };
67558     }
67559   }
67560
67561   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67562   return jresult;
67563 }
67564
67565
67566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67567   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67568   std::string *arg2 = 0 ;
67569
67570   arg1 = (Dali::Toolkit::Control *)jarg1;
67571   if (!jarg2) {
67572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67573     return ;
67574   }
67575   std::string arg2_str(jarg2);
67576   arg2 = &arg2_str;
67577   {
67578     try {
67579       (arg1)->SetStyleName((std::string const &)*arg2);
67580     } catch (std::out_of_range& e) {
67581       {
67582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67583       };
67584     } catch (std::exception& e) {
67585       {
67586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67587       };
67588     } catch (Dali::DaliException e) {
67589       {
67590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67591       };
67592     } catch (...) {
67593       {
67594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67595       };
67596     }
67597   }
67598
67599
67600   //argout typemap for const std::string&
67601
67602 }
67603
67604
67605 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67606   char * jresult ;
67607   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67608   std::string *result = 0 ;
67609
67610   arg1 = (Dali::Toolkit::Control *)jarg1;
67611   {
67612     try {
67613       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67614     } catch (std::out_of_range& e) {
67615       {
67616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67617       };
67618     } catch (std::exception& e) {
67619       {
67620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67621       };
67622     } catch (Dali::DaliException e) {
67623       {
67624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67625       };
67626     } catch (...) {
67627       {
67628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67629       };
67630     }
67631   }
67632
67633   jresult = SWIG_csharp_string_callback(result->c_str());
67634   return jresult;
67635 }
67636
67637
67638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67639   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67640   Dali::Vector4 *arg2 = 0 ;
67641
67642   arg1 = (Dali::Toolkit::Control *)jarg1;
67643   arg2 = (Dali::Vector4 *)jarg2;
67644   if (!arg2) {
67645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67646     return ;
67647   }
67648   {
67649     try {
67650       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67651     } catch (std::out_of_range& e) {
67652       {
67653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67654       };
67655     } catch (std::exception& e) {
67656       {
67657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67658       };
67659     } catch (Dali::DaliException e) {
67660       {
67661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67662       };
67663     } catch (...) {
67664       {
67665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67666       };
67667     }
67668   }
67669
67670 }
67671
67672
67673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67674   void * jresult ;
67675   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67676   Dali::Vector4 result;
67677
67678   arg1 = (Dali::Toolkit::Control *)jarg1;
67679   {
67680     try {
67681       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67682     } catch (std::out_of_range& e) {
67683       {
67684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67685       };
67686     } catch (std::exception& e) {
67687       {
67688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67689       };
67690     } catch (Dali::DaliException e) {
67691       {
67692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67693       };
67694     } catch (...) {
67695       {
67696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67697       };
67698     }
67699   }
67700
67701   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67702   return jresult;
67703 }
67704
67705
67706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67707   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67708   Dali::Image arg2 ;
67709   Dali::Image *argp2 ;
67710
67711   arg1 = (Dali::Toolkit::Control *)jarg1;
67712   argp2 = (Dali::Image *)jarg2;
67713   if (!argp2) {
67714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67715     return ;
67716   }
67717   arg2 = *argp2;
67718   {
67719     try {
67720       (arg1)->SetBackgroundImage(arg2);
67721     } catch (std::out_of_range& e) {
67722       {
67723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67724       };
67725     } catch (std::exception& e) {
67726       {
67727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67728       };
67729     } catch (Dali::DaliException e) {
67730       {
67731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67732       };
67733     } catch (...) {
67734       {
67735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67736       };
67737     }
67738   }
67739
67740 }
67741
67742
67743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67744   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67745
67746   arg1 = (Dali::Toolkit::Control *)jarg1;
67747   {
67748     try {
67749       (arg1)->ClearBackground();
67750     } catch (std::out_of_range& e) {
67751       {
67752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67753       };
67754     } catch (std::exception& e) {
67755       {
67756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67757       };
67758     } catch (Dali::DaliException e) {
67759       {
67760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67761       };
67762     } catch (...) {
67763       {
67764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67765       };
67766     }
67767   }
67768
67769 }
67770
67771
67772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67773   void * jresult ;
67774   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67775   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67776
67777   arg1 = (Dali::Toolkit::Control *)jarg1;
67778   {
67779     try {
67780       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67781     } catch (std::out_of_range& e) {
67782       {
67783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67784       };
67785     } catch (std::exception& e) {
67786       {
67787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67788       };
67789     } catch (Dali::DaliException e) {
67790       {
67791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67792       };
67793     } catch (...) {
67794       {
67795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67796       };
67797     }
67798   }
67799
67800   jresult = (void *)result;
67801   return jresult;
67802 }
67803
67804
67805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67806   void * jresult ;
67807   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67808   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67809
67810   arg1 = (Dali::Toolkit::Control *)jarg1;
67811   {
67812     try {
67813       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67814     } catch (std::out_of_range& e) {
67815       {
67816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67817       };
67818     } catch (std::exception& e) {
67819       {
67820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (Dali::DaliException e) {
67823       {
67824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67825       };
67826     } catch (...) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67829       };
67830     }
67831   }
67832
67833   jresult = (void *)result;
67834   return jresult;
67835 }
67836
67837
67838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67839   void * jresult ;
67840   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67841   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67842
67843   arg1 = (Dali::Toolkit::Control *)jarg1;
67844   {
67845     try {
67846       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67847     } catch (std::out_of_range& e) {
67848       {
67849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67850       };
67851     } catch (std::exception& e) {
67852       {
67853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67854       };
67855     } catch (Dali::DaliException e) {
67856       {
67857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67858       };
67859     } catch (...) {
67860       {
67861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67862       };
67863     }
67864   }
67865
67866   jresult = (void *)result;
67867   return jresult;
67868 }
67869
67870
67871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67872   void * jresult ;
67873   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67874   Dali::Toolkit::Control *result = 0 ;
67875
67876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67877   if (!arg1) {
67878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67879     return 0;
67880   }
67881   {
67882     try {
67883       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67884     } catch (std::out_of_range& e) {
67885       {
67886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67887       };
67888     } catch (std::exception& e) {
67889       {
67890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67891       };
67892     } catch (Dali::DaliException e) {
67893       {
67894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67895       };
67896     } catch (...) {
67897       {
67898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67899       };
67900     }
67901   }
67902
67903   jresult = (void *)result;
67904   return jresult;
67905 }
67906
67907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67908 {
67909   int jresult;
67910   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67911   arg1 = (Dali::Toolkit::Control *)jarg1;
67912
67913   if (!arg1) {
67914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67915     return 0;
67916   }
67917
67918   Dali::Property::Index arg2 = 0 ;
67919   arg2 = (Dali::Property::Index)jarg2;
67920
67921   Toolkit::Visual::ResourceStatus result;
67922   {
67923     try {
67924       result = arg1->GetVisualResourceStatus(arg2);
67925     } catch (std::out_of_range& e) {
67926       {
67927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67928       };
67929     } catch (std::exception& e) {
67930       {
67931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67932       };
67933     } catch (...) {
67934       {
67935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67936       };
67937     }
67938   }
67939   jresult = (int)(result);
67940   return jresult;
67941 }
67942
67943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67944 {
67945   void * jresult;
67946   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67947   arg1 = (Dali::Toolkit::Control *)jarg1;
67948
67949   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67950
67951   Dali::Toolkit::TransitionData *arg2 = 0 ;
67952   Dali::Animation result;
67953
67954   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67955   if (!arg2) {
67956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67957     return 0;
67958   }
67959   {
67960     try {
67961       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67962     } catch (std::out_of_range& e) {
67963       {
67964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (std::exception& e) {
67967       {
67968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67969       };
67970     } catch (Dali::DaliException e) {
67971       {
67972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67973       };
67974     } catch (...) {
67975       {
67976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67977       };
67978     }
67979   }
67980
67981   jresult = new Dali::Animation((const Dali::Animation &)result);
67982   return jresult;
67983 }
67984
67985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67986 {
67987   Dali::Toolkit::Control arg1;
67988   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67989
67990   if (!argp1) {
67991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67992   }
67993   arg1 = *argp1;
67994
67995   Dali::Property::Index arg2 = 0 ;
67996   arg2 = (Dali::Property::Index)jarg2;
67997
67998   Dali::Property::Index arg3 = 0 ;
67999   arg3 = (Dali::Property::Index)jarg3;
68000
68001   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
68002
68003   {
68004     try {
68005       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
68006     } catch (std::out_of_range& e) {
68007       {
68008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68009       };
68010     } catch (std::exception& e) {
68011       {
68012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68013       };
68014     } catch (...) {
68015       {
68016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68017       };
68018     }
68019   }
68020
68021
68022 }
68023
68024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68025   void * jresult ;
68026   Dali::Toolkit::Control *arg1 = 0 ;
68027   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68028
68029   arg1 = (Dali::Toolkit::Control *)jarg1;
68030   if (!arg1) {
68031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68032     return 0;
68033   }
68034   {
68035     try {
68036       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68037     } catch (std::out_of_range& e) {
68038       {
68039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68040       };
68041     } catch (std::exception& e) {
68042       {
68043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68044       };
68045     } catch (Dali::DaliException e) {
68046       {
68047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68048       };
68049     } catch (...) {
68050       {
68051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68052       };
68053     }
68054   }
68055
68056   jresult = (void *)result;
68057   return jresult;
68058 }
68059
68060
68061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68062   unsigned int jresult ;
68063   Dali::Toolkit::Control *arg1 = 0 ;
68064   bool result;
68065
68066   arg1 = (Dali::Toolkit::Control *)jarg1;
68067   if (!arg1) {
68068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68069     return 0;
68070   }
68071   {
68072     try {
68073       result = (bool)arg1->IsResourceReady();
68074     } catch (std::out_of_range& e) {
68075       {
68076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68077       };
68078     } catch (std::exception& e) {
68079       {
68080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68081       };
68082     } catch (Dali::DaliException e) {
68083       {
68084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68085       };
68086     } catch (...) {
68087       {
68088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68089       };
68090     }
68091   }
68092
68093   jresult = result;
68094   return jresult;
68095 }
68096
68097
68098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68099   void * jresult ;
68100   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68101
68102   {
68103     try {
68104       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68105     } catch (std::out_of_range& e) {
68106       {
68107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68108       };
68109     } catch (std::exception& e) {
68110       {
68111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68112       };
68113     } catch (Dali::DaliException e) {
68114       {
68115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68116       };
68117     } catch (...) {
68118       {
68119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68120       };
68121     }
68122   }
68123
68124   jresult = (void *)result;
68125   return jresult;
68126 }
68127
68128
68129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68130   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68131
68132   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68133   {
68134     try {
68135       delete arg1;
68136     } catch (std::out_of_range& e) {
68137       {
68138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68139       };
68140     } catch (std::exception& e) {
68141       {
68142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68143       };
68144     } catch (Dali::DaliException e) {
68145       {
68146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68147       };
68148     } catch (...) {
68149       {
68150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68151       };
68152     }
68153   }
68154
68155 }
68156
68157
68158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68159   void * jresult ;
68160   Dali::Toolkit::KeyInputFocusManager result;
68161
68162   {
68163     try {
68164       result = Dali::Toolkit::KeyInputFocusManager::Get();
68165     } catch (std::out_of_range& e) {
68166       {
68167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68168       };
68169     } catch (std::exception& e) {
68170       {
68171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68172       };
68173     } catch (Dali::DaliException e) {
68174       {
68175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68176       };
68177     } catch (...) {
68178       {
68179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68180       };
68181     }
68182   }
68183
68184   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68185   return jresult;
68186 }
68187
68188
68189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68190   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68191   Dali::Toolkit::Control arg2 ;
68192   Dali::Toolkit::Control *argp2 ;
68193
68194   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68195   argp2 = (Dali::Toolkit::Control *)jarg2;
68196   if (!argp2) {
68197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68198     return ;
68199   }
68200   arg2 = *argp2;
68201   {
68202     try {
68203       (arg1)->SetFocus(arg2);
68204     } catch (std::out_of_range& e) {
68205       {
68206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68207       };
68208     } catch (std::exception& e) {
68209       {
68210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68211       };
68212     } catch (Dali::DaliException e) {
68213       {
68214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68215       };
68216     } catch (...) {
68217       {
68218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68219       };
68220     }
68221   }
68222
68223 }
68224
68225
68226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68227   void * jresult ;
68228   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68229   Dali::Toolkit::Control result;
68230
68231   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68232   {
68233     try {
68234       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68235     } catch (std::out_of_range& e) {
68236       {
68237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68238       };
68239     } catch (std::exception& e) {
68240       {
68241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68242       };
68243     } catch (Dali::DaliException e) {
68244       {
68245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68246       };
68247     } catch (...) {
68248       {
68249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68250       };
68251     }
68252   }
68253
68254   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68255   return jresult;
68256 }
68257
68258
68259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68260   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68261   Dali::Toolkit::Control arg2 ;
68262   Dali::Toolkit::Control *argp2 ;
68263
68264   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68265   argp2 = (Dali::Toolkit::Control *)jarg2;
68266   if (!argp2) {
68267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68268     return ;
68269   }
68270   arg2 = *argp2;
68271   {
68272     try {
68273       (arg1)->RemoveFocus(arg2);
68274     } catch (std::out_of_range& e) {
68275       {
68276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68277       };
68278     } catch (std::exception& e) {
68279       {
68280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68281       };
68282     } catch (Dali::DaliException e) {
68283       {
68284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68285       };
68286     } catch (...) {
68287       {
68288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68289       };
68290     }
68291   }
68292
68293 }
68294
68295
68296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68297   void * jresult ;
68298   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68299   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68300
68301   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68302   {
68303     try {
68304       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68305     } catch (std::out_of_range& e) {
68306       {
68307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68308       };
68309     } catch (std::exception& e) {
68310       {
68311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68312       };
68313     } catch (Dali::DaliException e) {
68314       {
68315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68316       };
68317     } catch (...) {
68318       {
68319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68320       };
68321     }
68322   }
68323
68324   jresult = (void *)result;
68325   return jresult;
68326 }
68327
68328
68329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68330   void * jresult ;
68331   Dali::Toolkit::Alignment::Padding *result = 0 ;
68332
68333   {
68334     try {
68335       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68336     } catch (std::out_of_range& e) {
68337       {
68338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68339       };
68340     } catch (std::exception& e) {
68341       {
68342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68343       };
68344     } catch (Dali::DaliException e) {
68345       {
68346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68347       };
68348     } catch (...) {
68349       {
68350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68351       };
68352     }
68353   }
68354
68355   jresult = (void *)result;
68356   return jresult;
68357 }
68358
68359
68360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68361   void * jresult ;
68362   float arg1 ;
68363   float arg2 ;
68364   float arg3 ;
68365   float arg4 ;
68366   Dali::Toolkit::Alignment::Padding *result = 0 ;
68367
68368   arg1 = (float)jarg1;
68369   arg2 = (float)jarg2;
68370   arg3 = (float)jarg3;
68371   arg4 = (float)jarg4;
68372   {
68373     try {
68374       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68375     } catch (std::out_of_range& e) {
68376       {
68377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68378       };
68379     } catch (std::exception& e) {
68380       {
68381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68382       };
68383     } catch (Dali::DaliException e) {
68384       {
68385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68386       };
68387     } catch (...) {
68388       {
68389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68390       };
68391     }
68392   }
68393
68394   jresult = (void *)result;
68395   return jresult;
68396 }
68397
68398
68399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68400   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68401   float arg2 ;
68402
68403   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68404   arg2 = (float)jarg2;
68405   if (arg1) (arg1)->left = arg2;
68406 }
68407
68408
68409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68410   float jresult ;
68411   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68412   float result;
68413
68414   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68415   result = (float) ((arg1)->left);
68416   jresult = result;
68417   return jresult;
68418 }
68419
68420
68421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68422   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68423   float arg2 ;
68424
68425   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68426   arg2 = (float)jarg2;
68427   if (arg1) (arg1)->right = arg2;
68428 }
68429
68430
68431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68432   float jresult ;
68433   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68434   float result;
68435
68436   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68437   result = (float) ((arg1)->right);
68438   jresult = result;
68439   return jresult;
68440 }
68441
68442
68443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68444   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68445   float arg2 ;
68446
68447   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68448   arg2 = (float)jarg2;
68449   if (arg1) (arg1)->top = arg2;
68450 }
68451
68452
68453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68454   float jresult ;
68455   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68456   float result;
68457
68458   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68459   result = (float) ((arg1)->top);
68460   jresult = result;
68461   return jresult;
68462 }
68463
68464
68465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68466   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68467   float arg2 ;
68468
68469   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68470   arg2 = (float)jarg2;
68471   if (arg1) (arg1)->bottom = arg2;
68472 }
68473
68474
68475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68476   float jresult ;
68477   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68478   float result;
68479
68480   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68481   result = (float) ((arg1)->bottom);
68482   jresult = result;
68483   return jresult;
68484 }
68485
68486
68487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68488   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68489
68490   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68491   {
68492     try {
68493       delete arg1;
68494     } catch (std::out_of_range& e) {
68495       {
68496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68497       };
68498     } catch (std::exception& e) {
68499       {
68500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68501       };
68502     } catch (Dali::DaliException e) {
68503       {
68504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68505       };
68506     } catch (...) {
68507       {
68508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68509       };
68510     }
68511   }
68512
68513 }
68514
68515
68516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68517   void * jresult ;
68518   Dali::Toolkit::Alignment *result = 0 ;
68519
68520   {
68521     try {
68522       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68523     } catch (std::out_of_range& e) {
68524       {
68525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68526       };
68527     } catch (std::exception& e) {
68528       {
68529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68530       };
68531     } catch (Dali::DaliException e) {
68532       {
68533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68534       };
68535     } catch (...) {
68536       {
68537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68538       };
68539     }
68540   }
68541
68542   jresult = (void *)result;
68543   return jresult;
68544 }
68545
68546
68547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68548   void * jresult ;
68549   Dali::Toolkit::Alignment::Type arg1 ;
68550   Dali::Toolkit::Alignment::Type arg2 ;
68551   Dali::Toolkit::Alignment result;
68552
68553   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68554   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68555   {
68556     try {
68557       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68558     } catch (std::out_of_range& e) {
68559       {
68560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68561       };
68562     } catch (std::exception& e) {
68563       {
68564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68565       };
68566     } catch (Dali::DaliException e) {
68567       {
68568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68569       };
68570     } catch (...) {
68571       {
68572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68573       };
68574     }
68575   }
68576
68577   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68578   return jresult;
68579 }
68580
68581
68582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68583   void * jresult ;
68584   Dali::Toolkit::Alignment::Type arg1 ;
68585   Dali::Toolkit::Alignment result;
68586
68587   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68588   {
68589     try {
68590       result = Dali::Toolkit::Alignment::New(arg1);
68591     } catch (std::out_of_range& e) {
68592       {
68593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68594       };
68595     } catch (std::exception& e) {
68596       {
68597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68598       };
68599     } catch (Dali::DaliException e) {
68600       {
68601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68602       };
68603     } catch (...) {
68604       {
68605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68606       };
68607     }
68608   }
68609
68610   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68611   return jresult;
68612 }
68613
68614
68615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68616   void * jresult ;
68617   Dali::Toolkit::Alignment result;
68618
68619   {
68620     try {
68621       result = Dali::Toolkit::Alignment::New();
68622     } catch (std::out_of_range& e) {
68623       {
68624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68625       };
68626     } catch (std::exception& e) {
68627       {
68628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68629       };
68630     } catch (Dali::DaliException e) {
68631       {
68632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68633       };
68634     } catch (...) {
68635       {
68636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68637       };
68638     }
68639   }
68640
68641   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68642   return jresult;
68643 }
68644
68645
68646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68647   void * jresult ;
68648   Dali::Toolkit::Alignment *arg1 = 0 ;
68649   Dali::Toolkit::Alignment *result = 0 ;
68650
68651   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68652   if (!arg1) {
68653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68654     return 0;
68655   }
68656   {
68657     try {
68658       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68659     } catch (std::out_of_range& e) {
68660       {
68661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68662       };
68663     } catch (std::exception& e) {
68664       {
68665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68666       };
68667     } catch (Dali::DaliException e) {
68668       {
68669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68670       };
68671     } catch (...) {
68672       {
68673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68674       };
68675     }
68676   }
68677
68678   jresult = (void *)result;
68679   return jresult;
68680 }
68681
68682
68683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68684   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68685
68686   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68687   {
68688     try {
68689       delete arg1;
68690     } catch (std::out_of_range& e) {
68691       {
68692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68693       };
68694     } catch (std::exception& e) {
68695       {
68696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68697       };
68698     } catch (Dali::DaliException e) {
68699       {
68700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68701       };
68702     } catch (...) {
68703       {
68704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68705       };
68706     }
68707   }
68708
68709 }
68710
68711
68712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68713   void * jresult ;
68714   Dali::BaseHandle arg1 ;
68715   Dali::BaseHandle *argp1 ;
68716   Dali::Toolkit::Alignment result;
68717
68718   argp1 = (Dali::BaseHandle *)jarg1;
68719   if (!argp1) {
68720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68721     return 0;
68722   }
68723   arg1 = *argp1;
68724   {
68725     try {
68726       result = Dali::Toolkit::Alignment::DownCast(arg1);
68727     } catch (std::out_of_range& e) {
68728       {
68729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68730       };
68731     } catch (std::exception& e) {
68732       {
68733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68734       };
68735     } catch (Dali::DaliException e) {
68736       {
68737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68738       };
68739     } catch (...) {
68740       {
68741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68742       };
68743     }
68744   }
68745
68746   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68747   return jresult;
68748 }
68749
68750
68751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68752   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68753   Dali::Toolkit::Alignment::Type arg2 ;
68754
68755   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68756   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68757   {
68758     try {
68759       (arg1)->SetAlignmentType(arg2);
68760     } catch (std::out_of_range& e) {
68761       {
68762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68763       };
68764     } catch (std::exception& e) {
68765       {
68766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68767       };
68768     } catch (Dali::DaliException e) {
68769       {
68770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68771       };
68772     } catch (...) {
68773       {
68774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68775       };
68776     }
68777   }
68778
68779 }
68780
68781
68782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68783   int jresult ;
68784   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68785   Dali::Toolkit::Alignment::Type result;
68786
68787   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68788   {
68789     try {
68790       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68791     } catch (std::out_of_range& e) {
68792       {
68793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68794       };
68795     } catch (std::exception& e) {
68796       {
68797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68798       };
68799     } catch (Dali::DaliException e) {
68800       {
68801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68802       };
68803     } catch (...) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68806       };
68807     }
68808   }
68809
68810   jresult = (int)result;
68811   return jresult;
68812 }
68813
68814
68815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68816   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68817   Dali::Toolkit::Alignment::Scaling arg2 ;
68818
68819   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68820   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68821   {
68822     try {
68823       (arg1)->SetScaling(arg2);
68824     } catch (std::out_of_range& e) {
68825       {
68826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68827       };
68828     } catch (std::exception& e) {
68829       {
68830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68831       };
68832     } catch (Dali::DaliException e) {
68833       {
68834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68835       };
68836     } catch (...) {
68837       {
68838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68839       };
68840     }
68841   }
68842
68843 }
68844
68845
68846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68847   int jresult ;
68848   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68849   Dali::Toolkit::Alignment::Scaling result;
68850
68851   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68852   {
68853     try {
68854       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68855     } catch (std::out_of_range& e) {
68856       {
68857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68858       };
68859     } catch (std::exception& e) {
68860       {
68861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68862       };
68863     } catch (Dali::DaliException e) {
68864       {
68865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68866       };
68867     } catch (...) {
68868       {
68869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68870       };
68871     }
68872   }
68873
68874   jresult = (int)result;
68875   return jresult;
68876 }
68877
68878
68879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68880   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68881   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68882
68883   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68884   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68885   if (!arg2) {
68886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68887     return ;
68888   }
68889   {
68890     try {
68891       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68892     } catch (std::out_of_range& e) {
68893       {
68894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68895       };
68896     } catch (std::exception& e) {
68897       {
68898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68899       };
68900     } catch (Dali::DaliException e) {
68901       {
68902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68903       };
68904     } catch (...) {
68905       {
68906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68907       };
68908     }
68909   }
68910
68911 }
68912
68913
68914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68915   void * jresult ;
68916   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68917   Dali::Toolkit::Alignment::Padding *result = 0 ;
68918
68919   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68920   {
68921     try {
68922       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68923     } catch (std::out_of_range& e) {
68924       {
68925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68926       };
68927     } catch (std::exception& e) {
68928       {
68929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68930       };
68931     } catch (Dali::DaliException e) {
68932       {
68933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68934       };
68935     } catch (...) {
68936       {
68937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68938       };
68939     }
68940   }
68941
68942   jresult = (void *)result;
68943   return jresult;
68944 }
68945
68946
68947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68948   void * jresult ;
68949   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68950   Dali::Toolkit::Alignment *arg2 = 0 ;
68951   Dali::Toolkit::Alignment *result = 0 ;
68952
68953   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68954   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68955   if (!arg2) {
68956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68957     return 0;
68958   }
68959   {
68960     try {
68961       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68962     } catch (std::out_of_range& e) {
68963       {
68964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68965       };
68966     } catch (std::exception& e) {
68967       {
68968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68969       };
68970     } catch (Dali::DaliException e) {
68971       {
68972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68973       };
68974     } catch (...) {
68975       {
68976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68977       };
68978     }
68979   }
68980
68981   jresult = (void *)result;
68982   return jresult;
68983 }
68984
68985
68986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68987   int jresult ;
68988   int result;
68989
68990   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68991   jresult = (int)result;
68992   return jresult;
68993 }
68994
68995
68996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68997   int jresult ;
68998   int result;
68999
69000   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69001   jresult = (int)result;
69002   return jresult;
69003 }
69004
69005
69006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69007   int jresult ;
69008   int result;
69009
69010   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69011   jresult = (int)result;
69012   return jresult;
69013 }
69014
69015
69016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69017   int jresult ;
69018   int result;
69019
69020   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69021   jresult = (int)result;
69022   return jresult;
69023 }
69024
69025
69026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69027   int jresult ;
69028   int result;
69029
69030   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69031   jresult = (int)result;
69032   return jresult;
69033 }
69034
69035
69036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69037   int jresult ;
69038   int result;
69039
69040   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69041   jresult = (int)result;
69042   return jresult;
69043 }
69044
69045
69046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69047   int jresult ;
69048   int result;
69049
69050   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69051   jresult = (int)result;
69052   return jresult;
69053 }
69054
69055
69056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69057   int jresult ;
69058   int result;
69059
69060   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69061   jresult = (int)result;
69062   return jresult;
69063 }
69064
69065
69066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69067   int jresult ;
69068   int result;
69069
69070   result = (int)Dali::Toolkit::Button::Property::LABEL;
69071   jresult = (int)result;
69072   return jresult;
69073 }
69074
69075
69076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69077   int jresult ;
69078   int result;
69079
69080   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69081   jresult = (int)result;
69082   return jresult;
69083 }
69084
69085
69086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69087   void * jresult ;
69088   Dali::Toolkit::Button::Property *result = 0 ;
69089
69090   {
69091     try {
69092       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69093     } catch (std::out_of_range& e) {
69094       {
69095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69096       };
69097     } catch (std::exception& e) {
69098       {
69099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69100       };
69101     } catch (Dali::DaliException e) {
69102       {
69103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69104       };
69105     } catch (...) {
69106       {
69107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69108       };
69109     }
69110   }
69111
69112   jresult = (void *)result;
69113   return jresult;
69114 }
69115
69116
69117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69118   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69119
69120   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69121   {
69122     try {
69123       delete arg1;
69124     } catch (std::out_of_range& e) {
69125       {
69126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69127       };
69128     } catch (std::exception& e) {
69129       {
69130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69131       };
69132     } catch (Dali::DaliException e) {
69133       {
69134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69135       };
69136     } catch (...) {
69137       {
69138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69139       };
69140     }
69141   }
69142
69143 }
69144
69145
69146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69147   void * jresult ;
69148   Dali::Toolkit::Button *result = 0 ;
69149
69150   {
69151     try {
69152       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69153     } catch (std::out_of_range& e) {
69154       {
69155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69156       };
69157     } catch (std::exception& e) {
69158       {
69159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69160       };
69161     } catch (Dali::DaliException e) {
69162       {
69163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69164       };
69165     } catch (...) {
69166       {
69167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69168       };
69169     }
69170   }
69171
69172   jresult = (void *)result;
69173   return jresult;
69174 }
69175
69176
69177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69178   void * jresult ;
69179   Dali::Toolkit::Button *arg1 = 0 ;
69180   Dali::Toolkit::Button *result = 0 ;
69181
69182   arg1 = (Dali::Toolkit::Button *)jarg1;
69183   if (!arg1) {
69184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69185     return 0;
69186   }
69187   {
69188     try {
69189       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69190     } catch (std::out_of_range& e) {
69191       {
69192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69193       };
69194     } catch (std::exception& e) {
69195       {
69196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69197       };
69198     } catch (Dali::DaliException e) {
69199       {
69200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69201       };
69202     } catch (...) {
69203       {
69204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69205       };
69206     }
69207   }
69208
69209   jresult = (void *)result;
69210   return jresult;
69211 }
69212
69213
69214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69215   void * jresult ;
69216   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69217   Dali::Toolkit::Button *arg2 = 0 ;
69218   Dali::Toolkit::Button *result = 0 ;
69219
69220   arg1 = (Dali::Toolkit::Button *)jarg1;
69221   arg2 = (Dali::Toolkit::Button *)jarg2;
69222   if (!arg2) {
69223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69224     return 0;
69225   }
69226   {
69227     try {
69228       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69229     } catch (std::out_of_range& e) {
69230       {
69231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69232       };
69233     } catch (std::exception& e) {
69234       {
69235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69236       };
69237     } catch (Dali::DaliException e) {
69238       {
69239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69240       };
69241     } catch (...) {
69242       {
69243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69244       };
69245     }
69246   }
69247
69248   jresult = (void *)result;
69249   return jresult;
69250 }
69251
69252
69253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69254   void * jresult ;
69255   Dali::BaseHandle arg1 ;
69256   Dali::BaseHandle *argp1 ;
69257   Dali::Toolkit::Button result;
69258
69259   argp1 = (Dali::BaseHandle *)jarg1;
69260   if (!argp1) {
69261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69262     return 0;
69263   }
69264   arg1 = *argp1;
69265   {
69266     try {
69267       result = Dali::Toolkit::Button::DownCast(arg1);
69268     } catch (std::out_of_range& e) {
69269       {
69270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69271       };
69272     } catch (std::exception& e) {
69273       {
69274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69275       };
69276     } catch (Dali::DaliException e) {
69277       {
69278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69279       };
69280     } catch (...) {
69281       {
69282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69283       };
69284     }
69285   }
69286
69287   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69288   return jresult;
69289 }
69290
69291
69292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69293   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69294
69295   arg1 = (Dali::Toolkit::Button *)jarg1;
69296   {
69297     try {
69298       delete arg1;
69299     } catch (std::out_of_range& e) {
69300       {
69301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69302       };
69303     } catch (std::exception& e) {
69304       {
69305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69306       };
69307     } catch (Dali::DaliException e) {
69308       {
69309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69310       };
69311     } catch (...) {
69312       {
69313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69314       };
69315     }
69316   }
69317
69318 }
69319
69320
69321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69322   unsigned int jresult ;
69323   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69324   bool result;
69325
69326   arg1 = (Dali::Toolkit::Button *)jarg1;
69327   {
69328     try {
69329       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69330     } catch (std::out_of_range& e) {
69331       {
69332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69333       };
69334     } catch (std::exception& e) {
69335       {
69336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69337       };
69338     } catch (Dali::DaliException e) {
69339       {
69340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69341       };
69342     } catch (...) {
69343       {
69344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69345       };
69346     }
69347   }
69348
69349   jresult = result;
69350   return jresult;
69351 }
69352
69353
69354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69355   unsigned int jresult ;
69356   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69357   bool result;
69358
69359   arg1 = (Dali::Toolkit::Button *)jarg1;
69360   {
69361     try {
69362       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69363     } catch (std::out_of_range& e) {
69364       {
69365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69366       };
69367     } catch (std::exception& e) {
69368       {
69369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69370       };
69371     } catch (Dali::DaliException e) {
69372       {
69373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69374       };
69375     } catch (...) {
69376       {
69377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69378       };
69379     }
69380   }
69381
69382   jresult = result;
69383   return jresult;
69384 }
69385
69386
69387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69388   float jresult ;
69389   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69390   float result;
69391
69392   arg1 = (Dali::Toolkit::Button *)jarg1;
69393   {
69394     try {
69395       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69396     } catch (std::out_of_range& e) {
69397       {
69398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69399       };
69400     } catch (std::exception& e) {
69401       {
69402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69403       };
69404     } catch (Dali::DaliException e) {
69405       {
69406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69407       };
69408     } catch (...) {
69409       {
69410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69411       };
69412     }
69413   }
69414
69415   jresult = result;
69416   return jresult;
69417 }
69418
69419
69420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69421   float jresult ;
69422   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69423   float result;
69424
69425   arg1 = (Dali::Toolkit::Button *)jarg1;
69426   {
69427     try {
69428       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69429     } catch (std::out_of_range& e) {
69430       {
69431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69432       };
69433     } catch (std::exception& e) {
69434       {
69435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69436       };
69437     } catch (Dali::DaliException e) {
69438       {
69439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69440       };
69441     } catch (...) {
69442       {
69443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69444       };
69445     }
69446   }
69447
69448   jresult = result;
69449   return jresult;
69450 }
69451
69452
69453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69454   unsigned int jresult ;
69455   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69456   bool result;
69457
69458   arg1 = (Dali::Toolkit::Button *)jarg1;
69459   {
69460     try {
69461       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69462     } catch (std::out_of_range& e) {
69463       {
69464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69465       };
69466     } catch (std::exception& e) {
69467       {
69468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69469       };
69470     } catch (Dali::DaliException e) {
69471       {
69472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69473       };
69474     } catch (...) {
69475       {
69476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69477       };
69478     }
69479   }
69480
69481   jresult = result;
69482   return jresult;
69483 }
69484
69485
69486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69487   unsigned int jresult ;
69488   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69489   bool result;
69490
69491   arg1 = (Dali::Toolkit::Button *)jarg1;
69492   {
69493     try {
69494       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69495     } catch (std::out_of_range& e) {
69496       {
69497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69498       };
69499     } catch (std::exception& e) {
69500       {
69501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69502       };
69503     } catch (Dali::DaliException e) {
69504       {
69505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69506       };
69507     } catch (...) {
69508       {
69509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69510       };
69511     }
69512   }
69513
69514   jresult = result;
69515   return jresult;
69516 }
69517
69518
69519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69520   float jresult ;
69521   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69522   float result;
69523
69524   arg1 = (Dali::Toolkit::Button *)jarg1;
69525   {
69526     try {
69527       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69528     } catch (std::out_of_range& e) {
69529       {
69530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69531       };
69532     } catch (std::exception& e) {
69533       {
69534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69535       };
69536     } catch (Dali::DaliException e) {
69537       {
69538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69539       };
69540     } catch (...) {
69541       {
69542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69543       };
69544     }
69545   }
69546
69547   jresult = result;
69548   return jresult;
69549 }
69550
69551
69552 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69553   char * jresult ;
69554   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69555   std::string result;
69556
69557   arg1 = (Dali::Toolkit::Button *)jarg1;
69558   {
69559     try {
69560       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69561     } catch (std::out_of_range& e) {
69562       {
69563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69564       };
69565     } catch (std::exception& e) {
69566       {
69567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69568       };
69569     } catch (Dali::DaliException e) {
69570       {
69571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69572       };
69573     } catch (...) {
69574       {
69575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69576       };
69577     }
69578   }
69579
69580   jresult = SWIG_csharp_string_callback((&result)->c_str());
69581   return jresult;
69582 }
69583
69584
69585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69586   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69587   Dali::Actor arg2 ;
69588   Dali::Actor *argp2 ;
69589
69590   arg1 = (Dali::Toolkit::Button *)jarg1;
69591   argp2 = (Dali::Actor *)jarg2;
69592   if (!argp2) {
69593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69594     return ;
69595   }
69596   arg2 = *argp2;
69597   {
69598     try {
69599       (arg1)->SetLabel(arg2);
69600     } catch (std::out_of_range& e) {
69601       {
69602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69603       };
69604     } catch (std::exception& e) {
69605       {
69606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69607       };
69608     } catch (Dali::DaliException e) {
69609       {
69610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69611       };
69612     } catch (...) {
69613       {
69614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69615       };
69616     }
69617   }
69618
69619 }
69620
69621
69622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69623   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69624   Dali::Image arg2 ;
69625   Dali::Image *argp2 ;
69626
69627   arg1 = (Dali::Toolkit::Button *)jarg1;
69628   argp2 = (Dali::Image *)jarg2;
69629   if (!argp2) {
69630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69631     return ;
69632   }
69633   arg2 = *argp2;
69634   {
69635     try {
69636       (arg1)->SetButtonImage(arg2);
69637     } catch (std::out_of_range& e) {
69638       {
69639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69640       };
69641     } catch (std::exception& e) {
69642       {
69643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69644       };
69645     } catch (Dali::DaliException e) {
69646       {
69647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69648       };
69649     } catch (...) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69652       };
69653     }
69654   }
69655
69656 }
69657
69658
69659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69660   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69661   Dali::Image arg2 ;
69662   Dali::Image *argp2 ;
69663
69664   arg1 = (Dali::Toolkit::Button *)jarg1;
69665   argp2 = (Dali::Image *)jarg2;
69666   if (!argp2) {
69667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69668     return ;
69669   }
69670   arg2 = *argp2;
69671   {
69672     try {
69673       (arg1)->SetSelectedImage(arg2);
69674     } catch (std::out_of_range& e) {
69675       {
69676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69677       };
69678     } catch (std::exception& e) {
69679       {
69680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69681       };
69682     } catch (Dali::DaliException e) {
69683       {
69684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69685       };
69686     } catch (...) {
69687       {
69688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69689       };
69690     }
69691   }
69692
69693 }
69694
69695
69696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69697   void * jresult ;
69698   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69699   Dali::Actor result;
69700
69701   arg1 = (Dali::Toolkit::Button *)jarg1;
69702   {
69703     try {
69704       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69705     } catch (std::out_of_range& e) {
69706       {
69707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69708       };
69709     } catch (std::exception& e) {
69710       {
69711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69712       };
69713     } catch (Dali::DaliException e) {
69714       {
69715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69716       };
69717     } catch (...) {
69718       {
69719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69720       };
69721     }
69722   }
69723
69724   jresult = new Dali::Actor((const Dali::Actor &)result);
69725   return jresult;
69726 }
69727
69728
69729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69730   void * jresult ;
69731   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69732   Dali::Actor result;
69733
69734   arg1 = (Dali::Toolkit::Button *)jarg1;
69735   {
69736     try {
69737       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69738     } catch (std::out_of_range& e) {
69739       {
69740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69741       };
69742     } catch (std::exception& e) {
69743       {
69744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69745       };
69746     } catch (Dali::DaliException e) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69749       };
69750     } catch (...) {
69751       {
69752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69753       };
69754     }
69755   }
69756
69757   jresult = new Dali::Actor((const Dali::Actor &)result);
69758   return jresult;
69759 }
69760
69761
69762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69763   void * jresult ;
69764   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69765   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69766
69767   arg1 = (Dali::Toolkit::Button *)jarg1;
69768   {
69769     try {
69770       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69771     } catch (std::out_of_range& e) {
69772       {
69773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69774       };
69775     } catch (std::exception& e) {
69776       {
69777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69778       };
69779     } catch (Dali::DaliException e) {
69780       {
69781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69782       };
69783     } catch (...) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69786       };
69787     }
69788   }
69789
69790   jresult = (void *)result;
69791   return jresult;
69792 }
69793
69794
69795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69796   void * jresult ;
69797   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69798   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69799
69800   arg1 = (Dali::Toolkit::Button *)jarg1;
69801   {
69802     try {
69803       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69804     } catch (std::out_of_range& e) {
69805       {
69806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69807       };
69808     } catch (std::exception& e) {
69809       {
69810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (Dali::DaliException e) {
69813       {
69814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69815       };
69816     } catch (...) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69819       };
69820     }
69821   }
69822
69823   jresult = (void *)result;
69824   return jresult;
69825 }
69826
69827
69828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69829   void * jresult ;
69830   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69831   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69832
69833   arg1 = (Dali::Toolkit::Button *)jarg1;
69834   {
69835     try {
69836       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69837     } catch (std::out_of_range& e) {
69838       {
69839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69840       };
69841     } catch (std::exception& e) {
69842       {
69843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69844       };
69845     } catch (Dali::DaliException e) {
69846       {
69847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69848       };
69849     } catch (...) {
69850       {
69851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69852       };
69853     }
69854   }
69855
69856   jresult = (void *)result;
69857   return jresult;
69858 }
69859
69860
69861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69862   void * jresult ;
69863   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69864   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69865
69866   arg1 = (Dali::Toolkit::Button *)jarg1;
69867   {
69868     try {
69869       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69870     } catch (std::out_of_range& e) {
69871       {
69872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69873       };
69874     } catch (std::exception& e) {
69875       {
69876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69877       };
69878     } catch (Dali::DaliException e) {
69879       {
69880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69881       };
69882     } catch (...) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69885       };
69886     }
69887   }
69888
69889   jresult = (void *)result;
69890   return jresult;
69891 }
69892
69893
69894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69895   void * jresult ;
69896   Dali::Toolkit::CheckBoxButton *result = 0 ;
69897
69898   {
69899     try {
69900       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69901     } catch (std::out_of_range& e) {
69902       {
69903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69904       };
69905     } catch (std::exception& e) {
69906       {
69907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69908       };
69909     } catch (Dali::DaliException e) {
69910       {
69911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69912       };
69913     } catch (...) {
69914       {
69915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69916       };
69917     }
69918   }
69919
69920   jresult = (void *)result;
69921   return jresult;
69922 }
69923
69924
69925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69926   void * jresult ;
69927   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69928   Dali::Toolkit::CheckBoxButton *result = 0 ;
69929
69930   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69931   if (!arg1) {
69932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69933     return 0;
69934   }
69935   {
69936     try {
69937       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69938     } catch (std::out_of_range& e) {
69939       {
69940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69941       };
69942     } catch (std::exception& e) {
69943       {
69944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (Dali::DaliException e) {
69947       {
69948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69949       };
69950     } catch (...) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69953       };
69954     }
69955   }
69956
69957   jresult = (void *)result;
69958   return jresult;
69959 }
69960
69961
69962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69963   void * jresult ;
69964   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69965   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69966   Dali::Toolkit::CheckBoxButton *result = 0 ;
69967
69968   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69969   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69970   if (!arg2) {
69971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69972     return 0;
69973   }
69974   {
69975     try {
69976       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69977     } catch (std::out_of_range& e) {
69978       {
69979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69980       };
69981     } catch (std::exception& e) {
69982       {
69983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (Dali::DaliException e) {
69986       {
69987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69988       };
69989     } catch (...) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69992       };
69993     }
69994   }
69995
69996   jresult = (void *)result;
69997   return jresult;
69998 }
69999
70000
70001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70002   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70003
70004   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70005   {
70006     try {
70007       delete arg1;
70008     } catch (std::out_of_range& e) {
70009       {
70010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70011       };
70012     } catch (std::exception& e) {
70013       {
70014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70015       };
70016     } catch (Dali::DaliException e) {
70017       {
70018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70019       };
70020     } catch (...) {
70021       {
70022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70023       };
70024     }
70025   }
70026
70027 }
70028
70029
70030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70031   void * jresult ;
70032   Dali::Toolkit::CheckBoxButton result;
70033
70034   {
70035     try {
70036       result = Dali::Toolkit::CheckBoxButton::New();
70037     } catch (std::out_of_range& e) {
70038       {
70039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70040       };
70041     } catch (std::exception& e) {
70042       {
70043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70044       };
70045     } catch (Dali::DaliException e) {
70046       {
70047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70048       };
70049     } catch (...) {
70050       {
70051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70052       };
70053     }
70054   }
70055
70056   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70057   return jresult;
70058 }
70059
70060
70061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70062   void * jresult ;
70063   Dali::BaseHandle arg1 ;
70064   Dali::BaseHandle *argp1 ;
70065   Dali::Toolkit::CheckBoxButton result;
70066
70067   argp1 = (Dali::BaseHandle *)jarg1;
70068   if (!argp1) {
70069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70070     return 0;
70071   }
70072   arg1 = *argp1;
70073   {
70074     try {
70075       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70076     } catch (std::out_of_range& e) {
70077       {
70078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70079       };
70080     } catch (std::exception& e) {
70081       {
70082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70083       };
70084     } catch (Dali::DaliException e) {
70085       {
70086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70087       };
70088     } catch (...) {
70089       {
70090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70091       };
70092     }
70093   }
70094
70095   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70096   return jresult;
70097 }
70098
70099
70100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70101   int jresult ;
70102   int result;
70103
70104   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70105   jresult = (int)result;
70106   return jresult;
70107 }
70108
70109
70110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70111   int jresult ;
70112   int result;
70113
70114   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70115   jresult = (int)result;
70116   return jresult;
70117 }
70118
70119
70120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70121   int jresult ;
70122   int result;
70123
70124   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70125   jresult = (int)result;
70126   return jresult;
70127 }
70128
70129
70130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70131   int jresult ;
70132   int result;
70133
70134   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70135   jresult = (int)result;
70136   return jresult;
70137 }
70138
70139
70140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70141   int jresult ;
70142   int result;
70143
70144   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70145   jresult = (int)result;
70146   return jresult;
70147 }
70148
70149
70150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70151   void * jresult ;
70152   Dali::Toolkit::PushButton::Property *result = 0 ;
70153
70154   {
70155     try {
70156       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70157     } catch (std::out_of_range& e) {
70158       {
70159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70160       };
70161     } catch (std::exception& e) {
70162       {
70163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70164       };
70165     } catch (Dali::DaliException e) {
70166       {
70167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70168       };
70169     } catch (...) {
70170       {
70171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70172       };
70173     }
70174   }
70175
70176   jresult = (void *)result;
70177   return jresult;
70178 }
70179
70180
70181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70182   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70183
70184   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70185   {
70186     try {
70187       delete arg1;
70188     } catch (std::out_of_range& e) {
70189       {
70190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70191       };
70192     } catch (std::exception& e) {
70193       {
70194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70195       };
70196     } catch (Dali::DaliException e) {
70197       {
70198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70199       };
70200     } catch (...) {
70201       {
70202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70203       };
70204     }
70205   }
70206
70207 }
70208
70209
70210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70211   void * jresult ;
70212   Dali::Toolkit::PushButton *result = 0 ;
70213
70214   {
70215     try {
70216       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70217     } catch (std::out_of_range& e) {
70218       {
70219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70220       };
70221     } catch (std::exception& e) {
70222       {
70223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70224       };
70225     } catch (Dali::DaliException e) {
70226       {
70227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70228       };
70229     } catch (...) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70232       };
70233     }
70234   }
70235
70236   jresult = (void *)result;
70237   return jresult;
70238 }
70239
70240
70241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70242   void * jresult ;
70243   Dali::Toolkit::PushButton *arg1 = 0 ;
70244   Dali::Toolkit::PushButton *result = 0 ;
70245
70246   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70247   if (!arg1) {
70248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70249     return 0;
70250   }
70251   {
70252     try {
70253       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70254     } catch (std::out_of_range& e) {
70255       {
70256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70257       };
70258     } catch (std::exception& e) {
70259       {
70260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70261       };
70262     } catch (Dali::DaliException e) {
70263       {
70264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70265       };
70266     } catch (...) {
70267       {
70268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70269       };
70270     }
70271   }
70272
70273   jresult = (void *)result;
70274   return jresult;
70275 }
70276
70277
70278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70279   void * jresult ;
70280   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70281   Dali::Toolkit::PushButton *arg2 = 0 ;
70282   Dali::Toolkit::PushButton *result = 0 ;
70283
70284   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70285   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70286   if (!arg2) {
70287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70288     return 0;
70289   }
70290   {
70291     try {
70292       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70293     } catch (std::out_of_range& e) {
70294       {
70295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70296       };
70297     } catch (std::exception& e) {
70298       {
70299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70300       };
70301     } catch (Dali::DaliException e) {
70302       {
70303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70304       };
70305     } catch (...) {
70306       {
70307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70308       };
70309     }
70310   }
70311
70312   jresult = (void *)result;
70313   return jresult;
70314 }
70315
70316
70317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70318   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70319
70320   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70321   {
70322     try {
70323       delete arg1;
70324     } catch (std::out_of_range& e) {
70325       {
70326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70327       };
70328     } catch (std::exception& e) {
70329       {
70330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70331       };
70332     } catch (Dali::DaliException e) {
70333       {
70334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70335       };
70336     } catch (...) {
70337       {
70338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70339       };
70340     }
70341   }
70342
70343 }
70344
70345
70346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70347   void * jresult ;
70348   Dali::Toolkit::PushButton result;
70349
70350   {
70351     try {
70352       result = Dali::Toolkit::PushButton::New();
70353     } catch (std::out_of_range& e) {
70354       {
70355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70356       };
70357     } catch (std::exception& e) {
70358       {
70359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70360       };
70361     } catch (Dali::DaliException e) {
70362       {
70363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70364       };
70365     } catch (...) {
70366       {
70367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70368       };
70369     }
70370   }
70371
70372   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70373   return jresult;
70374 }
70375
70376
70377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70378   void * jresult ;
70379   Dali::BaseHandle arg1 ;
70380   Dali::BaseHandle *argp1 ;
70381   Dali::Toolkit::PushButton result;
70382
70383   argp1 = (Dali::BaseHandle *)jarg1;
70384   if (!argp1) {
70385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70386     return 0;
70387   }
70388   arg1 = *argp1;
70389   {
70390     try {
70391       result = Dali::Toolkit::PushButton::DownCast(arg1);
70392     } catch (std::out_of_range& e) {
70393       {
70394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70395       };
70396     } catch (std::exception& e) {
70397       {
70398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70399       };
70400     } catch (Dali::DaliException e) {
70401       {
70402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70403       };
70404     } catch (...) {
70405       {
70406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70407       };
70408     }
70409   }
70410
70411   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70412   return jresult;
70413 }
70414
70415
70416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70417   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70418   Dali::Image arg2 ;
70419   Dali::Image *argp2 ;
70420
70421   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70422   argp2 = (Dali::Image *)jarg2;
70423   if (!argp2) {
70424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70425     return ;
70426   }
70427   arg2 = *argp2;
70428   {
70429     try {
70430       (arg1)->SetButtonImage(arg2);
70431     } catch (std::out_of_range& e) {
70432       {
70433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70434       };
70435     } catch (std::exception& e) {
70436       {
70437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70438       };
70439     } catch (Dali::DaliException e) {
70440       {
70441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70442       };
70443     } catch (...) {
70444       {
70445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70446       };
70447     }
70448   }
70449
70450 }
70451
70452
70453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70454   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70455   Dali::Actor arg2 ;
70456   Dali::Actor *argp2 ;
70457
70458   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70459   argp2 = (Dali::Actor *)jarg2;
70460   if (!argp2) {
70461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70462     return ;
70463   }
70464   arg2 = *argp2;
70465   {
70466     try {
70467       (arg1)->SetButtonImage(arg2);
70468     } catch (std::out_of_range& e) {
70469       {
70470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70471       };
70472     } catch (std::exception& e) {
70473       {
70474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70475       };
70476     } catch (Dali::DaliException e) {
70477       {
70478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70479       };
70480     } catch (...) {
70481       {
70482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70483       };
70484     }
70485   }
70486
70487 }
70488
70489
70490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70491   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70492   Dali::Actor arg2 ;
70493   Dali::Actor *argp2 ;
70494
70495   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70496   argp2 = (Dali::Actor *)jarg2;
70497   if (!argp2) {
70498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70499     return ;
70500   }
70501   arg2 = *argp2;
70502   {
70503     try {
70504       (arg1)->SetBackgroundImage(arg2);
70505     } catch (std::out_of_range& e) {
70506       {
70507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70508       };
70509     } catch (std::exception& e) {
70510       {
70511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70512       };
70513     } catch (Dali::DaliException e) {
70514       {
70515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70516       };
70517     } catch (...) {
70518       {
70519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70520       };
70521     }
70522   }
70523
70524 }
70525
70526
70527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70528   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70529   Dali::Image arg2 ;
70530   Dali::Image *argp2 ;
70531
70532   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70533   argp2 = (Dali::Image *)jarg2;
70534   if (!argp2) {
70535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70536     return ;
70537   }
70538   arg2 = *argp2;
70539   {
70540     try {
70541       (arg1)->SetSelectedImage(arg2);
70542     } catch (std::out_of_range& e) {
70543       {
70544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70545       };
70546     } catch (std::exception& e) {
70547       {
70548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70549       };
70550     } catch (Dali::DaliException e) {
70551       {
70552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70553       };
70554     } catch (...) {
70555       {
70556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70557       };
70558     }
70559   }
70560
70561 }
70562
70563
70564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70565   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70566   Dali::Actor arg2 ;
70567   Dali::Actor *argp2 ;
70568
70569   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70570   argp2 = (Dali::Actor *)jarg2;
70571   if (!argp2) {
70572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70573     return ;
70574   }
70575   arg2 = *argp2;
70576   {
70577     try {
70578       (arg1)->SetSelectedImage(arg2);
70579     } catch (std::out_of_range& e) {
70580       {
70581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70582       };
70583     } catch (std::exception& e) {
70584       {
70585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70586       };
70587     } catch (Dali::DaliException e) {
70588       {
70589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70590       };
70591     } catch (...) {
70592       {
70593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70594       };
70595     }
70596   }
70597
70598 }
70599
70600
70601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70602   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70603   Dali::Actor arg2 ;
70604   Dali::Actor *argp2 ;
70605
70606   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70607   argp2 = (Dali::Actor *)jarg2;
70608   if (!argp2) {
70609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70610     return ;
70611   }
70612   arg2 = *argp2;
70613   {
70614     try {
70615       (arg1)->SetSelectedBackgroundImage(arg2);
70616     } catch (std::out_of_range& e) {
70617       {
70618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70619       };
70620     } catch (std::exception& e) {
70621       {
70622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70623       };
70624     } catch (Dali::DaliException e) {
70625       {
70626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70627       };
70628     } catch (...) {
70629       {
70630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70631       };
70632     }
70633   }
70634
70635 }
70636
70637
70638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70639   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70640   Dali::Actor arg2 ;
70641   Dali::Actor *argp2 ;
70642
70643   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70644   argp2 = (Dali::Actor *)jarg2;
70645   if (!argp2) {
70646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70647     return ;
70648   }
70649   arg2 = *argp2;
70650   {
70651     try {
70652       (arg1)->SetDisabledBackgroundImage(arg2);
70653     } catch (std::out_of_range& e) {
70654       {
70655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70656       };
70657     } catch (std::exception& e) {
70658       {
70659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70660       };
70661     } catch (Dali::DaliException e) {
70662       {
70663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70664       };
70665     } catch (...) {
70666       {
70667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70668       };
70669     }
70670   }
70671
70672 }
70673
70674
70675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70676   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70677   Dali::Actor arg2 ;
70678   Dali::Actor *argp2 ;
70679
70680   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70681   argp2 = (Dali::Actor *)jarg2;
70682   if (!argp2) {
70683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70684     return ;
70685   }
70686   arg2 = *argp2;
70687   {
70688     try {
70689       (arg1)->SetDisabledImage(arg2);
70690     } catch (std::out_of_range& e) {
70691       {
70692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70693       };
70694     } catch (std::exception& e) {
70695       {
70696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70697       };
70698     } catch (Dali::DaliException e) {
70699       {
70700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70701       };
70702     } catch (...) {
70703       {
70704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70705       };
70706     }
70707   }
70708
70709 }
70710
70711
70712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70713   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70714   Dali::Actor arg2 ;
70715   Dali::Actor *argp2 ;
70716
70717   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70718   argp2 = (Dali::Actor *)jarg2;
70719   if (!argp2) {
70720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70721     return ;
70722   }
70723   arg2 = *argp2;
70724   {
70725     try {
70726       (arg1)->SetDisabledSelectedImage(arg2);
70727     } catch (std::out_of_range& e) {
70728       {
70729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70730       };
70731     } catch (std::exception& e) {
70732       {
70733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70734       };
70735     } catch (Dali::DaliException e) {
70736       {
70737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70738       };
70739     } catch (...) {
70740       {
70741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70742       };
70743     }
70744   }
70745
70746 }
70747
70748
70749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70750   void * jresult ;
70751   Dali::Toolkit::RadioButton *result = 0 ;
70752
70753   {
70754     try {
70755       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70756     } catch (std::out_of_range& e) {
70757       {
70758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70759       };
70760     } catch (std::exception& e) {
70761       {
70762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70763       };
70764     } catch (Dali::DaliException e) {
70765       {
70766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70767       };
70768     } catch (...) {
70769       {
70770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70771       };
70772     }
70773   }
70774
70775   jresult = (void *)result;
70776   return jresult;
70777 }
70778
70779
70780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70781   void * jresult ;
70782   Dali::Toolkit::RadioButton *arg1 = 0 ;
70783   Dali::Toolkit::RadioButton *result = 0 ;
70784
70785   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70786   if (!arg1) {
70787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70788     return 0;
70789   }
70790   {
70791     try {
70792       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
70793     } catch (std::out_of_range& e) {
70794       {
70795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70796       };
70797     } catch (std::exception& e) {
70798       {
70799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70800       };
70801     } catch (Dali::DaliException e) {
70802       {
70803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70804       };
70805     } catch (...) {
70806       {
70807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70808       };
70809     }
70810   }
70811
70812   jresult = (void *)result;
70813   return jresult;
70814 }
70815
70816
70817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
70818   void * jresult ;
70819   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70820   Dali::Toolkit::RadioButton *arg2 = 0 ;
70821   Dali::Toolkit::RadioButton *result = 0 ;
70822
70823   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70824   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
70825   if (!arg2) {
70826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70827     return 0;
70828   }
70829   {
70830     try {
70831       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
70832     } catch (std::out_of_range& e) {
70833       {
70834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70835       };
70836     } catch (std::exception& e) {
70837       {
70838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70839       };
70840     } catch (Dali::DaliException e) {
70841       {
70842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70843       };
70844     } catch (...) {
70845       {
70846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70847       };
70848     }
70849   }
70850
70851   jresult = (void *)result;
70852   return jresult;
70853 }
70854
70855
70856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70857   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70858
70859   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70860   {
70861     try {
70862       delete arg1;
70863     } catch (std::out_of_range& e) {
70864       {
70865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70866       };
70867     } catch (std::exception& e) {
70868       {
70869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70870       };
70871     } catch (Dali::DaliException e) {
70872       {
70873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70874       };
70875     } catch (...) {
70876       {
70877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70878       };
70879     }
70880   }
70881
70882 }
70883
70884
70885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70886   void * jresult ;
70887   Dali::Toolkit::RadioButton result;
70888
70889   {
70890     try {
70891       result = Dali::Toolkit::RadioButton::New();
70892     } catch (std::out_of_range& e) {
70893       {
70894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70895       };
70896     } catch (std::exception& e) {
70897       {
70898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70899       };
70900     } catch (Dali::DaliException e) {
70901       {
70902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70903       };
70904     } catch (...) {
70905       {
70906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70907       };
70908     }
70909   }
70910
70911   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70912   return jresult;
70913 }
70914
70915
70916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70917   void * jresult ;
70918   std::string *arg1 = 0 ;
70919   Dali::Toolkit::RadioButton result;
70920
70921   if (!jarg1) {
70922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70923     return 0;
70924   }
70925   std::string arg1_str(jarg1);
70926   arg1 = &arg1_str;
70927   {
70928     try {
70929       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70930     } catch (std::out_of_range& e) {
70931       {
70932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70933       };
70934     } catch (std::exception& e) {
70935       {
70936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70937       };
70938     } catch (Dali::DaliException e) {
70939       {
70940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70941       };
70942     } catch (...) {
70943       {
70944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70945       };
70946     }
70947   }
70948
70949   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70950
70951   //argout typemap for const std::string&
70952
70953   return jresult;
70954 }
70955
70956
70957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70958   void * jresult ;
70959   Dali::BaseHandle arg1 ;
70960   Dali::BaseHandle *argp1 ;
70961   Dali::Toolkit::RadioButton result;
70962
70963   argp1 = (Dali::BaseHandle *)jarg1;
70964   if (!argp1) {
70965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70966     return 0;
70967   }
70968   arg1 = *argp1;
70969   {
70970     try {
70971       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70972     } catch (std::out_of_range& e) {
70973       {
70974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70975       };
70976     } catch (std::exception& e) {
70977       {
70978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70979       };
70980     } catch (Dali::DaliException e) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70983       };
70984     } catch (...) {
70985       {
70986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70987       };
70988     }
70989   }
70990
70991   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70992   return jresult;
70993 }
70994
70995
70996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70997   int jresult ;
70998   int result;
70999
71000   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71001   jresult = (int)result;
71002   return jresult;
71003 }
71004
71005
71006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71007   int jresult ;
71008   int result;
71009
71010   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71011   jresult = (int)result;
71012   return jresult;
71013 }
71014
71015
71016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71017   int jresult ;
71018   int result;
71019
71020   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71021   jresult = (int)result;
71022   return jresult;
71023 }
71024
71025
71026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71027   int jresult ;
71028   int result;
71029
71030   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71031   jresult = (int)result;
71032   return jresult;
71033 }
71034
71035
71036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71037   int jresult ;
71038   int result;
71039
71040   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71041   jresult = (int)result;
71042   return jresult;
71043 }
71044
71045
71046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71047   int jresult ;
71048   int result;
71049
71050   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71051   jresult = (int)result;
71052   return jresult;
71053 }
71054
71055
71056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71057   void * jresult ;
71058   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71059
71060   {
71061     try {
71062       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71063     } catch (std::out_of_range& e) {
71064       {
71065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71066       };
71067     } catch (std::exception& e) {
71068       {
71069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71070       };
71071     } catch (Dali::DaliException e) {
71072       {
71073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71074       };
71075     } catch (...) {
71076       {
71077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71078       };
71079     }
71080   }
71081
71082   jresult = (void *)result;
71083   return jresult;
71084 }
71085
71086
71087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71088   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71089
71090   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71091   {
71092     try {
71093       delete arg1;
71094     } catch (std::out_of_range& e) {
71095       {
71096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71097       };
71098     } catch (std::exception& e) {
71099       {
71100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71101       };
71102     } catch (Dali::DaliException e) {
71103       {
71104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71105       };
71106     } catch (...) {
71107       {
71108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71109       };
71110     }
71111   }
71112
71113 }
71114
71115
71116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71117   int jresult ;
71118   int result;
71119
71120   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71121   jresult = (int)result;
71122   return jresult;
71123 }
71124
71125
71126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71127   int jresult ;
71128   int result;
71129
71130   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71131   jresult = (int)result;
71132   return jresult;
71133 }
71134
71135
71136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71137   int jresult ;
71138   int result;
71139
71140   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71141   jresult = (int)result;
71142   return jresult;
71143 }
71144
71145
71146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71147   void * jresult ;
71148   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71149
71150   {
71151     try {
71152       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71153     } catch (std::out_of_range& e) {
71154       {
71155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71156       };
71157     } catch (std::exception& e) {
71158       {
71159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71160       };
71161     } catch (Dali::DaliException e) {
71162       {
71163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71164       };
71165     } catch (...) {
71166       {
71167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71168       };
71169     }
71170   }
71171
71172   jresult = (void *)result;
71173   return jresult;
71174 }
71175
71176
71177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71178   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71179
71180   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71181   {
71182     try {
71183       delete arg1;
71184     } catch (std::out_of_range& e) {
71185       {
71186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71187       };
71188     } catch (std::exception& e) {
71189       {
71190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71191       };
71192     } catch (Dali::DaliException e) {
71193       {
71194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71195       };
71196     } catch (...) {
71197       {
71198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71199       };
71200     }
71201   }
71202
71203 }
71204
71205
71206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71207   void * jresult ;
71208   Dali::Toolkit::FlexContainer *result = 0 ;
71209
71210   {
71211     try {
71212       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71213     } catch (std::out_of_range& e) {
71214       {
71215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71216       };
71217     } catch (std::exception& e) {
71218       {
71219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71220       };
71221     } catch (Dali::DaliException e) {
71222       {
71223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71224       };
71225     } catch (...) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71228       };
71229     }
71230   }
71231
71232   jresult = (void *)result;
71233   return jresult;
71234 }
71235
71236
71237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71238   void * jresult ;
71239   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71240   Dali::Toolkit::FlexContainer *result = 0 ;
71241
71242   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71243   if (!arg1) {
71244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71245     return 0;
71246   }
71247   {
71248     try {
71249       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71250     } catch (std::out_of_range& e) {
71251       {
71252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71253       };
71254     } catch (std::exception& e) {
71255       {
71256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71257       };
71258     } catch (Dali::DaliException e) {
71259       {
71260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71261       };
71262     } catch (...) {
71263       {
71264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71265       };
71266     }
71267   }
71268
71269   jresult = (void *)result;
71270   return jresult;
71271 }
71272
71273
71274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71275   void * jresult ;
71276   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71277   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71278   Dali::Toolkit::FlexContainer *result = 0 ;
71279
71280   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71281   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71282   if (!arg2) {
71283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71284     return 0;
71285   }
71286   {
71287     try {
71288       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71289     } catch (std::out_of_range& e) {
71290       {
71291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71292       };
71293     } catch (std::exception& e) {
71294       {
71295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71296       };
71297     } catch (Dali::DaliException e) {
71298       {
71299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71300       };
71301     } catch (...) {
71302       {
71303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71304       };
71305     }
71306   }
71307
71308   jresult = (void *)result;
71309   return jresult;
71310 }
71311
71312
71313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71314   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71315
71316   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71317   {
71318     try {
71319       delete arg1;
71320     } catch (std::out_of_range& e) {
71321       {
71322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71323       };
71324     } catch (std::exception& e) {
71325       {
71326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71327       };
71328     } catch (Dali::DaliException e) {
71329       {
71330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71331       };
71332     } catch (...) {
71333       {
71334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71335       };
71336     }
71337   }
71338
71339 }
71340
71341
71342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71343   void * jresult ;
71344   Dali::Toolkit::FlexContainer result;
71345
71346   {
71347     try {
71348       result = Dali::Toolkit::FlexContainer::New();
71349     } catch (std::out_of_range& e) {
71350       {
71351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71352       };
71353     } catch (std::exception& e) {
71354       {
71355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71356       };
71357     } catch (Dali::DaliException e) {
71358       {
71359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71360       };
71361     } catch (...) {
71362       {
71363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71364       };
71365     }
71366   }
71367
71368   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71369   return jresult;
71370 }
71371
71372
71373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71374   void * jresult ;
71375   Dali::BaseHandle arg1 ;
71376   Dali::BaseHandle *argp1 ;
71377   Dali::Toolkit::FlexContainer result;
71378
71379   argp1 = (Dali::BaseHandle *)jarg1;
71380   if (!argp1) {
71381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71382     return 0;
71383   }
71384   arg1 = *argp1;
71385   {
71386     try {
71387       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71388     } catch (std::out_of_range& e) {
71389       {
71390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71391       };
71392     } catch (std::exception& e) {
71393       {
71394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71395       };
71396     } catch (Dali::DaliException e) {
71397       {
71398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71399       };
71400     } catch (...) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71403       };
71404     }
71405   }
71406
71407   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71408   return jresult;
71409 }
71410
71411
71412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71413   int jresult ;
71414   int result;
71415
71416   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71417   jresult = (int)result;
71418   return jresult;
71419 }
71420
71421
71422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71423   int jresult ;
71424   int result;
71425
71426   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71427   jresult = (int)result;
71428   return jresult;
71429 }
71430
71431
71432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71433   int jresult ;
71434   int result;
71435
71436   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71437   jresult = (int)result;
71438   return jresult;
71439 }
71440
71441
71442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71443   int jresult ;
71444   int result;
71445
71446   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71447   jresult = (int)result;
71448   return jresult;
71449 }
71450
71451
71452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71453   void * jresult ;
71454   Dali::Toolkit::ImageView::Property *result = 0 ;
71455
71456   {
71457     try {
71458       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71459     } catch (std::out_of_range& e) {
71460       {
71461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71462       };
71463     } catch (std::exception& e) {
71464       {
71465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71466       };
71467     } catch (Dali::DaliException e) {
71468       {
71469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71470       };
71471     } catch (...) {
71472       {
71473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71474       };
71475     }
71476   }
71477
71478   jresult = (void *)result;
71479   return jresult;
71480 }
71481
71482
71483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71484   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71485
71486   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71487   {
71488     try {
71489       delete arg1;
71490     } catch (std::out_of_range& e) {
71491       {
71492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71493       };
71494     } catch (std::exception& e) {
71495       {
71496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71497       };
71498     } catch (Dali::DaliException e) {
71499       {
71500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71501       };
71502     } catch (...) {
71503       {
71504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71505       };
71506     }
71507   }
71508
71509 }
71510
71511
71512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71513   void * jresult ;
71514   Dali::Toolkit::ImageView *result = 0 ;
71515
71516   {
71517     try {
71518       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71519     } catch (std::out_of_range& e) {
71520       {
71521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71522       };
71523     } catch (std::exception& e) {
71524       {
71525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71526       };
71527     } catch (Dali::DaliException e) {
71528       {
71529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71530       };
71531     } catch (...) {
71532       {
71533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71534       };
71535     }
71536   }
71537
71538   jresult = (void *)result;
71539   return jresult;
71540 }
71541
71542
71543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71544   void * jresult ;
71545   Dali::Toolkit::ImageView result;
71546
71547   {
71548     try {
71549       result = Dali::Toolkit::ImageView::New();
71550     } catch (std::out_of_range& e) {
71551       {
71552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71553       };
71554     } catch (std::exception& e) {
71555       {
71556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71557       };
71558     } catch (Dali::DaliException e) {
71559       {
71560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71561       };
71562     } catch (...) {
71563       {
71564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71565       };
71566     }
71567   }
71568
71569   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71570   return jresult;
71571 }
71572
71573
71574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71575   void * jresult ;
71576   Dali::Image arg1 ;
71577   Dali::Image *argp1 ;
71578   Dali::Toolkit::ImageView result;
71579
71580   argp1 = (Dali::Image *)jarg1;
71581   if (!argp1) {
71582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71583     return 0;
71584   }
71585   arg1 = *argp1;
71586   {
71587     try {
71588       result = Dali::Toolkit::ImageView::New(arg1);
71589     } catch (std::out_of_range& e) {
71590       {
71591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71592       };
71593     } catch (std::exception& e) {
71594       {
71595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71596       };
71597     } catch (Dali::DaliException e) {
71598       {
71599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71600       };
71601     } catch (...) {
71602       {
71603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71604       };
71605     }
71606   }
71607
71608   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71609   return jresult;
71610 }
71611
71612
71613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71614   void * jresult ;
71615   std::string *arg1 = 0 ;
71616   Dali::Toolkit::ImageView result;
71617
71618   if (!jarg1) {
71619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71620     return 0;
71621   }
71622   std::string arg1_str(jarg1);
71623   arg1 = &arg1_str;
71624   {
71625     try {
71626       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71627     } catch (std::out_of_range& e) {
71628       {
71629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71630       };
71631     } catch (std::exception& e) {
71632       {
71633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71634       };
71635     } catch (Dali::DaliException e) {
71636       {
71637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71638       };
71639     } catch (...) {
71640       {
71641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71642       };
71643     }
71644   }
71645
71646   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71647
71648   //argout typemap for const std::string&
71649
71650   return jresult;
71651 }
71652
71653
71654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71655   void * jresult ;
71656   std::string *arg1 = 0 ;
71657   Dali::ImageDimensions arg2 ;
71658   Dali::ImageDimensions *argp2 ;
71659   Dali::Toolkit::ImageView result;
71660
71661   if (!jarg1) {
71662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71663     return 0;
71664   }
71665   std::string arg1_str(jarg1);
71666   arg1 = &arg1_str;
71667   argp2 = (Dali::ImageDimensions *)jarg2;
71668   if (!argp2) {
71669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71670     return 0;
71671   }
71672   arg2 = *argp2;
71673   {
71674     try {
71675       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71676     } catch (std::out_of_range& e) {
71677       {
71678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71679       };
71680     } catch (std::exception& e) {
71681       {
71682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71683       };
71684     } catch (Dali::DaliException e) {
71685       {
71686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71687       };
71688     } catch (...) {
71689       {
71690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71691       };
71692     }
71693   }
71694
71695   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71696
71697   //argout typemap for const std::string&
71698
71699   return jresult;
71700 }
71701
71702
71703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71704   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71705
71706   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71707   {
71708     try {
71709       delete arg1;
71710     } catch (std::out_of_range& e) {
71711       {
71712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71713       };
71714     } catch (std::exception& e) {
71715       {
71716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71717       };
71718     } catch (Dali::DaliException e) {
71719       {
71720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71721       };
71722     } catch (...) {
71723       {
71724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71725       };
71726     }
71727   }
71728
71729 }
71730
71731
71732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71733   void * jresult ;
71734   Dali::Toolkit::ImageView *arg1 = 0 ;
71735   Dali::Toolkit::ImageView *result = 0 ;
71736
71737   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71738   if (!arg1) {
71739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71740     return 0;
71741   }
71742   {
71743     try {
71744       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71745     } catch (std::out_of_range& e) {
71746       {
71747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71748       };
71749     } catch (std::exception& e) {
71750       {
71751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71752       };
71753     } catch (Dali::DaliException e) {
71754       {
71755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71756       };
71757     } catch (...) {
71758       {
71759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71760       };
71761     }
71762   }
71763
71764   jresult = (void *)result;
71765   return jresult;
71766 }
71767
71768
71769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71770   void * jresult ;
71771   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71772   Dali::Toolkit::ImageView *arg2 = 0 ;
71773   Dali::Toolkit::ImageView *result = 0 ;
71774
71775   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71776   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71777   if (!arg2) {
71778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71779     return 0;
71780   }
71781   {
71782     try {
71783       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71784     } catch (std::out_of_range& e) {
71785       {
71786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71787       };
71788     } catch (std::exception& e) {
71789       {
71790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71791       };
71792     } catch (Dali::DaliException e) {
71793       {
71794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71795       };
71796     } catch (...) {
71797       {
71798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71799       };
71800     }
71801   }
71802
71803   jresult = (void *)result;
71804   return jresult;
71805 }
71806
71807
71808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
71809   void * jresult ;
71810   Dali::BaseHandle arg1 ;
71811   Dali::BaseHandle *argp1 ;
71812   Dali::Toolkit::ImageView result;
71813
71814   argp1 = (Dali::BaseHandle *)jarg1;
71815   if (!argp1) {
71816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71817     return 0;
71818   }
71819   arg1 = *argp1;
71820   {
71821     try {
71822       result = Dali::Toolkit::ImageView::DownCast(arg1);
71823     } catch (std::out_of_range& e) {
71824       {
71825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71826       };
71827     } catch (std::exception& e) {
71828       {
71829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71830       };
71831     } catch (Dali::DaliException e) {
71832       {
71833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71834       };
71835     } catch (...) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71838       };
71839     }
71840   }
71841
71842   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71843   return jresult;
71844 }
71845
71846
71847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
71848   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71849   Dali::Image arg2 ;
71850   Dali::Image *argp2 ;
71851
71852   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71853   argp2 = (Dali::Image *)jarg2;
71854   if (!argp2) {
71855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71856     return ;
71857   }
71858   arg2 = *argp2;
71859   {
71860     try {
71861       (arg1)->SetImage(arg2);
71862     } catch (std::out_of_range& e) {
71863       {
71864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71865       };
71866     } catch (std::exception& e) {
71867       {
71868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71869       };
71870     } catch (Dali::DaliException e) {
71871       {
71872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71873       };
71874     } catch (...) {
71875       {
71876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71877       };
71878     }
71879   }
71880
71881 }
71882
71883
71884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71885   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71886   std::string *arg2 = 0 ;
71887
71888   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71889   if (!jarg2) {
71890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71891     return ;
71892   }
71893   std::string arg2_str(jarg2);
71894   arg2 = &arg2_str;
71895   {
71896     try {
71897       (arg1)->SetImage((std::string const &)*arg2);
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
71923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71924   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71925   std::string *arg2 = 0 ;
71926   Dali::ImageDimensions arg3 ;
71927   Dali::ImageDimensions *argp3 ;
71928
71929   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71930   if (!jarg2) {
71931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71932     return ;
71933   }
71934   std::string arg2_str(jarg2);
71935   arg2 = &arg2_str;
71936   argp3 = (Dali::ImageDimensions *)jarg3;
71937   if (!argp3) {
71938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71939     return ;
71940   }
71941   arg3 = *argp3;
71942   {
71943     try {
71944       (arg1)->SetImage((std::string const &)*arg2,arg3);
71945     } catch (std::out_of_range& e) {
71946       {
71947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71948       };
71949     } catch (std::exception& e) {
71950       {
71951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71952       };
71953     } catch (Dali::DaliException e) {
71954       {
71955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71956       };
71957     } catch (...) {
71958       {
71959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71960       };
71961     }
71962   }
71963
71964
71965   //argout typemap for const std::string&
71966
71967 }
71968
71969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71970   void * jresult ;
71971   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71972   Dali::Image result;
71973
71974   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71975   {
71976     try {
71977       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71978     } catch (std::out_of_range& e) {
71979       {
71980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71981       };
71982     } catch (std::exception& e) {
71983       {
71984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71985       };
71986     } catch (Dali::DaliException e) {
71987       {
71988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71989       };
71990     } catch (...) {
71991       {
71992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71993       };
71994     }
71995   }
71996
71997   jresult = new Dali::Image((const Dali::Image &)result);
71998   return jresult;
71999 }
72000
72001
72002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72003   int jresult ;
72004   int result;
72005
72006   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72007   jresult = (int)result;
72008   return jresult;
72009 }
72010
72011
72012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72013   int jresult ;
72014   int result;
72015
72016   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72017   jresult = (int)result;
72018   return jresult;
72019 }
72020
72021
72022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72023   int jresult ;
72024   int result;
72025
72026   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72027   jresult = (int)result;
72028   return jresult;
72029 }
72030
72031
72032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72033   int jresult ;
72034   int result;
72035
72036   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72037   jresult = (int)result;
72038   return jresult;
72039 }
72040
72041
72042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72043   int jresult ;
72044   int result;
72045
72046   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72047   jresult = (int)result;
72048   return jresult;
72049 }
72050
72051
72052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72053   int jresult ;
72054   int result;
72055
72056   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72057   jresult = (int)result;
72058   return jresult;
72059 }
72060
72061
72062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72063   int jresult ;
72064   int result;
72065
72066   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72067   jresult = (int)result;
72068   return jresult;
72069 }
72070
72071
72072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72073   int jresult ;
72074   int result;
72075
72076   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72077   jresult = (int)result;
72078   return jresult;
72079 }
72080
72081
72082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72083   void * jresult ;
72084   Dali::Toolkit::Model3dView::Property *result = 0 ;
72085
72086   {
72087     try {
72088       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72089     } catch (std::out_of_range& e) {
72090       {
72091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72092       };
72093     } catch (std::exception& e) {
72094       {
72095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72096       };
72097     } catch (Dali::DaliException e) {
72098       {
72099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72100       };
72101     } catch (...) {
72102       {
72103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72104       };
72105     }
72106   }
72107
72108   jresult = (void *)result;
72109   return jresult;
72110 }
72111
72112
72113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72114   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72115
72116   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72117   {
72118     try {
72119       delete arg1;
72120     } catch (std::out_of_range& e) {
72121       {
72122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72123       };
72124     } catch (std::exception& e) {
72125       {
72126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72127       };
72128     } catch (Dali::DaliException e) {
72129       {
72130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72131       };
72132     } catch (...) {
72133       {
72134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72135       };
72136     }
72137   }
72138
72139 }
72140
72141
72142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72143   void * jresult ;
72144   Dali::Toolkit::Model3dView result;
72145
72146   {
72147     try {
72148       result = Dali::Toolkit::Model3dView::New();
72149     } catch (std::out_of_range& e) {
72150       {
72151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72152       };
72153     } catch (std::exception& e) {
72154       {
72155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72156       };
72157     } catch (Dali::DaliException e) {
72158       {
72159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72160       };
72161     } catch (...) {
72162       {
72163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72164       };
72165     }
72166   }
72167
72168   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72169   return jresult;
72170 }
72171
72172
72173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72174   void * jresult ;
72175   std::string *arg1 = 0 ;
72176   std::string *arg2 = 0 ;
72177   std::string *arg3 = 0 ;
72178   Dali::Toolkit::Model3dView result;
72179
72180   if (!jarg1) {
72181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72182     return 0;
72183   }
72184   std::string arg1_str(jarg1);
72185   arg1 = &arg1_str;
72186   if (!jarg2) {
72187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72188     return 0;
72189   }
72190   std::string arg2_str(jarg2);
72191   arg2 = &arg2_str;
72192   if (!jarg3) {
72193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72194     return 0;
72195   }
72196   std::string arg3_str(jarg3);
72197   arg3 = &arg3_str;
72198   {
72199     try {
72200       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72201     } catch (std::out_of_range& e) {
72202       {
72203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72204       };
72205     } catch (std::exception& e) {
72206       {
72207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72208       };
72209     } catch (Dali::DaliException e) {
72210       {
72211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72212       };
72213     } catch (...) {
72214       {
72215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72216       };
72217     }
72218   }
72219
72220   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72221
72222   //argout typemap for const std::string&
72223
72224
72225   //argout typemap for const std::string&
72226
72227
72228   //argout typemap for const std::string&
72229
72230   return jresult;
72231 }
72232
72233
72234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72235   void * jresult ;
72236   Dali::Toolkit::Model3dView *result = 0 ;
72237
72238   {
72239     try {
72240       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72241     } catch (std::out_of_range& e) {
72242       {
72243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72244       };
72245     } catch (std::exception& e) {
72246       {
72247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72248       };
72249     } catch (Dali::DaliException e) {
72250       {
72251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72252       };
72253     } catch (...) {
72254       {
72255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72256       };
72257     }
72258   }
72259
72260   jresult = (void *)result;
72261   return jresult;
72262 }
72263
72264
72265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72266   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72267
72268   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72269   {
72270     try {
72271       delete arg1;
72272     } catch (std::out_of_range& e) {
72273       {
72274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72275       };
72276     } catch (std::exception& e) {
72277       {
72278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72279       };
72280     } catch (Dali::DaliException e) {
72281       {
72282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72283       };
72284     } catch (...) {
72285       {
72286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72287       };
72288     }
72289   }
72290
72291 }
72292
72293
72294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72295   void * jresult ;
72296   Dali::Toolkit::Model3dView *arg1 = 0 ;
72297   Dali::Toolkit::Model3dView *result = 0 ;
72298
72299   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72300   if (!arg1) {
72301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72302     return 0;
72303   }
72304   {
72305     try {
72306       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72307     } catch (std::out_of_range& e) {
72308       {
72309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72310       };
72311     } catch (std::exception& e) {
72312       {
72313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72314       };
72315     } catch (Dali::DaliException e) {
72316       {
72317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72318       };
72319     } catch (...) {
72320       {
72321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72322       };
72323     }
72324   }
72325
72326   jresult = (void *)result;
72327   return jresult;
72328 }
72329
72330
72331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72332   void * jresult ;
72333   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72334   Dali::Toolkit::Model3dView *arg2 = 0 ;
72335   Dali::Toolkit::Model3dView *result = 0 ;
72336
72337   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72338   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72339   if (!arg2) {
72340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72341     return 0;
72342   }
72343   {
72344     try {
72345       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72346     } catch (std::out_of_range& e) {
72347       {
72348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72349       };
72350     } catch (std::exception& e) {
72351       {
72352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72353       };
72354     } catch (Dali::DaliException e) {
72355       {
72356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72357       };
72358     } catch (...) {
72359       {
72360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72361       };
72362     }
72363   }
72364
72365   jresult = (void *)result;
72366   return jresult;
72367 }
72368
72369
72370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72371   void * jresult ;
72372   Dali::BaseHandle arg1 ;
72373   Dali::BaseHandle *argp1 ;
72374   Dali::Toolkit::Model3dView result;
72375
72376   argp1 = (Dali::BaseHandle *)jarg1;
72377   if (!argp1) {
72378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72379     return 0;
72380   }
72381   arg1 = *argp1;
72382   {
72383     try {
72384       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72385     } catch (std::out_of_range& e) {
72386       {
72387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72388       };
72389     } catch (std::exception& e) {
72390       {
72391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (Dali::DaliException e) {
72394       {
72395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72396       };
72397     } catch (...) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72400       };
72401     }
72402   }
72403
72404   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72405   return jresult;
72406 }
72407
72408
72409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72410   int jresult ;
72411   int result;
72412
72413   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72414   jresult = (int)result;
72415   return jresult;
72416 }
72417
72418
72419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72420   int jresult ;
72421   int result;
72422
72423   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72424   jresult = (int)result;
72425   return jresult;
72426 }
72427
72428
72429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72430   int jresult ;
72431   int result;
72432
72433   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72434   jresult = (int)result;
72435   return jresult;
72436 }
72437
72438
72439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72440   int jresult ;
72441   int result;
72442
72443   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72444   jresult = (int)result;
72445   return jresult;
72446 }
72447
72448
72449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72450   int jresult ;
72451   int result;
72452
72453   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72454   jresult = (int)result;
72455   return jresult;
72456 }
72457
72458
72459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72460   int jresult ;
72461   int result;
72462
72463   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72464   jresult = (int)result;
72465   return jresult;
72466 }
72467
72468
72469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72470   int jresult ;
72471   int result;
72472
72473   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72474   jresult = (int)result;
72475   return jresult;
72476 }
72477
72478
72479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72480   int jresult ;
72481   int result;
72482
72483   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72484   jresult = (int)result;
72485   return jresult;
72486 }
72487
72488
72489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72490   int jresult ;
72491   int result;
72492
72493   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72494   jresult = (int)result;
72495   return jresult;
72496 }
72497
72498
72499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72500   void * jresult ;
72501   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72502
72503   {
72504     try {
72505       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72506     } catch (std::out_of_range& e) {
72507       {
72508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72509       };
72510     } catch (std::exception& e) {
72511       {
72512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72513       };
72514     } catch (Dali::DaliException e) {
72515       {
72516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72517       };
72518     } catch (...) {
72519       {
72520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72521       };
72522     }
72523   }
72524
72525   jresult = (void *)result;
72526   return jresult;
72527 }
72528
72529
72530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72531   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72532
72533   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72534   {
72535     try {
72536       delete arg1;
72537     } catch (std::out_of_range& e) {
72538       {
72539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72540       };
72541     } catch (std::exception& e) {
72542       {
72543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72544       };
72545     } catch (Dali::DaliException e) {
72546       {
72547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72548       };
72549     } catch (...) {
72550       {
72551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72552       };
72553     }
72554   }
72555
72556 }
72557
72558
72559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72560   void * jresult ;
72561   Dali::Toolkit::ScrollBar *result = 0 ;
72562
72563   {
72564     try {
72565       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72566     } catch (std::out_of_range& e) {
72567       {
72568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72569       };
72570     } catch (std::exception& e) {
72571       {
72572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72573       };
72574     } catch (Dali::DaliException e) {
72575       {
72576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72577       };
72578     } catch (...) {
72579       {
72580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72581       };
72582     }
72583   }
72584
72585   jresult = (void *)result;
72586   return jresult;
72587 }
72588
72589
72590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72591   void * jresult ;
72592   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72593   Dali::Toolkit::ScrollBar *result = 0 ;
72594
72595   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72596   if (!arg1) {
72597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72598     return 0;
72599   }
72600   {
72601     try {
72602       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72603     } catch (std::out_of_range& e) {
72604       {
72605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72606       };
72607     } catch (std::exception& e) {
72608       {
72609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72610       };
72611     } catch (Dali::DaliException e) {
72612       {
72613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72614       };
72615     } catch (...) {
72616       {
72617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72618       };
72619     }
72620   }
72621
72622   jresult = (void *)result;
72623   return jresult;
72624 }
72625
72626
72627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72628   void * jresult ;
72629   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72630   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72631   Dali::Toolkit::ScrollBar *result = 0 ;
72632
72633   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72634   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72635   if (!arg2) {
72636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72637     return 0;
72638   }
72639   {
72640     try {
72641       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72642     } catch (std::out_of_range& e) {
72643       {
72644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72645       };
72646     } catch (std::exception& e) {
72647       {
72648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72649       };
72650     } catch (Dali::DaliException e) {
72651       {
72652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72653       };
72654     } catch (...) {
72655       {
72656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72657       };
72658     }
72659   }
72660
72661   jresult = (void *)result;
72662   return jresult;
72663 }
72664
72665
72666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72667   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72668
72669   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72670   {
72671     try {
72672       delete arg1;
72673     } catch (std::out_of_range& e) {
72674       {
72675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72676       };
72677     } catch (std::exception& e) {
72678       {
72679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72680       };
72681     } catch (Dali::DaliException e) {
72682       {
72683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72684       };
72685     } catch (...) {
72686       {
72687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72688       };
72689     }
72690   }
72691
72692 }
72693
72694
72695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72696   void * jresult ;
72697   Dali::Toolkit::ScrollBar::Direction arg1 ;
72698   Dali::Toolkit::ScrollBar result;
72699
72700   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72701   {
72702     try {
72703       result = Dali::Toolkit::ScrollBar::New(arg1);
72704     } catch (std::out_of_range& e) {
72705       {
72706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72707       };
72708     } catch (std::exception& e) {
72709       {
72710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72711       };
72712     } catch (Dali::DaliException e) {
72713       {
72714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72715       };
72716     } catch (...) {
72717       {
72718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72719       };
72720     }
72721   }
72722
72723   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72724   return jresult;
72725 }
72726
72727
72728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72729   void * jresult ;
72730   Dali::Toolkit::ScrollBar result;
72731
72732   {
72733     try {
72734       result = Dali::Toolkit::ScrollBar::New();
72735     } catch (std::out_of_range& e) {
72736       {
72737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72738       };
72739     } catch (std::exception& e) {
72740       {
72741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72742       };
72743     } catch (Dali::DaliException e) {
72744       {
72745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72746       };
72747     } catch (...) {
72748       {
72749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72750       };
72751     }
72752   }
72753
72754   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72755   return jresult;
72756 }
72757
72758
72759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72760   void * jresult ;
72761   Dali::BaseHandle arg1 ;
72762   Dali::BaseHandle *argp1 ;
72763   Dali::Toolkit::ScrollBar result;
72764
72765   argp1 = (Dali::BaseHandle *)jarg1;
72766   if (!argp1) {
72767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72768     return 0;
72769   }
72770   arg1 = *argp1;
72771   {
72772     try {
72773       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72774     } catch (std::out_of_range& e) {
72775       {
72776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72777       };
72778     } catch (std::exception& e) {
72779       {
72780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72781       };
72782     } catch (Dali::DaliException e) {
72783       {
72784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72785       };
72786     } catch (...) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72789       };
72790     }
72791   }
72792
72793   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72794   return jresult;
72795 }
72796
72797
72798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
72799   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72800   Dali::Handle arg2 ;
72801   Dali::Property::Index arg3 ;
72802   Dali::Property::Index arg4 ;
72803   Dali::Property::Index arg5 ;
72804   Dali::Property::Index arg6 ;
72805   Dali::Handle *argp2 ;
72806
72807   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72808   argp2 = (Dali::Handle *)jarg2;
72809   if (!argp2) {
72810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
72811     return ;
72812   }
72813   arg2 = *argp2;
72814   arg3 = (Dali::Property::Index)jarg3;
72815   arg4 = (Dali::Property::Index)jarg4;
72816   arg5 = (Dali::Property::Index)jarg5;
72817   arg6 = (Dali::Property::Index)jarg6;
72818   {
72819     try {
72820       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
72821     } catch (std::out_of_range& e) {
72822       {
72823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72824       };
72825     } catch (std::exception& e) {
72826       {
72827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72828       };
72829     } catch (Dali::DaliException e) {
72830       {
72831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72832       };
72833     } catch (...) {
72834       {
72835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72836       };
72837     }
72838   }
72839
72840 }
72841
72842
72843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
72844   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72845   Dali::Actor arg2 ;
72846   Dali::Actor *argp2 ;
72847
72848   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72849   argp2 = (Dali::Actor *)jarg2;
72850   if (!argp2) {
72851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72852     return ;
72853   }
72854   arg2 = *argp2;
72855   {
72856     try {
72857       (arg1)->SetScrollIndicator(arg2);
72858     } catch (std::out_of_range& e) {
72859       {
72860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72861       };
72862     } catch (std::exception& e) {
72863       {
72864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72865       };
72866     } catch (Dali::DaliException e) {
72867       {
72868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72869       };
72870     } catch (...) {
72871       {
72872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72873       };
72874     }
72875   }
72876
72877 }
72878
72879
72880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72881   void * jresult ;
72882   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72883   Dali::Actor result;
72884
72885   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72886   {
72887     try {
72888       result = (arg1)->GetScrollIndicator();
72889     } catch (std::out_of_range& e) {
72890       {
72891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72892       };
72893     } catch (std::exception& e) {
72894       {
72895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72896       };
72897     } catch (Dali::DaliException e) {
72898       {
72899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72900       };
72901     } catch (...) {
72902       {
72903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72904       };
72905     }
72906   }
72907
72908   jresult = new Dali::Actor((const Dali::Actor &)result);
72909   return jresult;
72910 }
72911
72912
72913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72914   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72915   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72916
72917   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72918   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72919   if (!arg2) {
72920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72921     return ;
72922   }
72923   {
72924     try {
72925       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72926     } catch (std::out_of_range& e) {
72927       {
72928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72929       };
72930     } catch (std::exception& e) {
72931       {
72932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72933       };
72934     } catch (Dali::DaliException e) {
72935       {
72936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72937       };
72938     } catch (...) {
72939       {
72940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72941       };
72942     }
72943   }
72944
72945 }
72946
72947
72948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72949   void * jresult ;
72950   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72951
72952   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72953   {
72954     try {
72955       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()));
72956     } catch (std::out_of_range& e) {
72957       {
72958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72959       };
72960     } catch (std::exception& e) {
72961       {
72962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72963       };
72964     } catch (...) {
72965       {
72966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72967       };
72968     }
72969   }
72970   return jresult;
72971 }
72972
72973
72974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72975   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72976   Dali::Toolkit::ScrollBar::Direction arg2 ;
72977
72978   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72979   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72980   {
72981     try {
72982       (arg1)->SetScrollDirection(arg2);
72983     } catch (std::out_of_range& e) {
72984       {
72985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72986       };
72987     } catch (std::exception& e) {
72988       {
72989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72990       };
72991     } catch (Dali::DaliException e) {
72992       {
72993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72994       };
72995     } catch (...) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72998       };
72999     }
73000   }
73001
73002 }
73003
73004
73005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73006   int jresult ;
73007   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73008   Dali::Toolkit::ScrollBar::Direction result;
73009
73010   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73011   {
73012     try {
73013       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73014     } catch (std::out_of_range& e) {
73015       {
73016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73017       };
73018     } catch (std::exception& e) {
73019       {
73020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73021       };
73022     } catch (Dali::DaliException e) {
73023       {
73024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73025       };
73026     } catch (...) {
73027       {
73028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73029       };
73030     }
73031   }
73032
73033   jresult = (int)result;
73034   return jresult;
73035 }
73036
73037
73038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73039   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73040   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73041
73042   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73043   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73044   {
73045     try {
73046       (arg1)->SetIndicatorHeightPolicy(arg2);
73047     } catch (std::out_of_range& e) {
73048       {
73049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73050       };
73051     } catch (std::exception& e) {
73052       {
73053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73054       };
73055     } catch (Dali::DaliException e) {
73056       {
73057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73058       };
73059     } catch (...) {
73060       {
73061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73062       };
73063     }
73064   }
73065
73066 }
73067
73068
73069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73070   int jresult ;
73071   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73072   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73073
73074   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73075   {
73076     try {
73077       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73078     } catch (std::out_of_range& e) {
73079       {
73080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73081       };
73082     } catch (std::exception& e) {
73083       {
73084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73085       };
73086     } catch (Dali::DaliException e) {
73087       {
73088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73089       };
73090     } catch (...) {
73091       {
73092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73093       };
73094     }
73095   }
73096
73097   jresult = (int)result;
73098   return jresult;
73099 }
73100
73101
73102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73103   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73104   float arg2 ;
73105
73106   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73107   arg2 = (float)jarg2;
73108   {
73109     try {
73110       (arg1)->SetIndicatorFixedHeight(arg2);
73111     } catch (std::out_of_range& e) {
73112       {
73113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73114       };
73115     } catch (std::exception& e) {
73116       {
73117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73118       };
73119     } catch (Dali::DaliException e) {
73120       {
73121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73122       };
73123     } catch (...) {
73124       {
73125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73126       };
73127     }
73128   }
73129
73130 }
73131
73132
73133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73134   float jresult ;
73135   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73136   float result;
73137
73138   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73139   {
73140     try {
73141       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73142     } catch (std::out_of_range& e) {
73143       {
73144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73145       };
73146     } catch (std::exception& e) {
73147       {
73148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73149       };
73150     } catch (Dali::DaliException e) {
73151       {
73152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73153       };
73154     } catch (...) {
73155       {
73156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73157       };
73158     }
73159   }
73160
73161   jresult = result;
73162   return jresult;
73163 }
73164
73165
73166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73167   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73168   float arg2 ;
73169
73170   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73171   arg2 = (float)jarg2;
73172   {
73173     try {
73174       (arg1)->SetIndicatorShowDuration(arg2);
73175     } catch (std::out_of_range& e) {
73176       {
73177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73178       };
73179     } catch (std::exception& e) {
73180       {
73181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73182       };
73183     } catch (Dali::DaliException e) {
73184       {
73185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73186       };
73187     } catch (...) {
73188       {
73189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73190       };
73191     }
73192   }
73193
73194 }
73195
73196
73197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73198   float jresult ;
73199   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73200   float result;
73201
73202   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73203   {
73204     try {
73205       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73206     } catch (std::out_of_range& e) {
73207       {
73208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73209       };
73210     } catch (std::exception& e) {
73211       {
73212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73213       };
73214     } catch (Dali::DaliException e) {
73215       {
73216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73217       };
73218     } catch (...) {
73219       {
73220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73221       };
73222     }
73223   }
73224
73225   jresult = result;
73226   return jresult;
73227 }
73228
73229
73230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73231   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73232   float arg2 ;
73233
73234   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73235   arg2 = (float)jarg2;
73236   {
73237     try {
73238       (arg1)->SetIndicatorHideDuration(arg2);
73239     } catch (std::out_of_range& e) {
73240       {
73241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73242       };
73243     } catch (std::exception& e) {
73244       {
73245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73246       };
73247     } catch (Dali::DaliException e) {
73248       {
73249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73250       };
73251     } catch (...) {
73252       {
73253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73254       };
73255     }
73256   }
73257
73258 }
73259
73260
73261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73262   float jresult ;
73263   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73264   float result;
73265
73266   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73267   {
73268     try {
73269       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73270     } catch (std::out_of_range& e) {
73271       {
73272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73273       };
73274     } catch (std::exception& e) {
73275       {
73276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73277       };
73278     } catch (Dali::DaliException e) {
73279       {
73280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73281       };
73282     } catch (...) {
73283       {
73284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73285       };
73286     }
73287   }
73288
73289   jresult = result;
73290   return jresult;
73291 }
73292
73293
73294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73295   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73296
73297   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73298   {
73299     try {
73300       (arg1)->ShowIndicator();
73301     } catch (std::out_of_range& e) {
73302       {
73303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73304       };
73305     } catch (std::exception& e) {
73306       {
73307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73308       };
73309     } catch (Dali::DaliException e) {
73310       {
73311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73312       };
73313     } catch (...) {
73314       {
73315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73316       };
73317     }
73318   }
73319
73320 }
73321
73322
73323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73324   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73325
73326   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73327   {
73328     try {
73329       (arg1)->HideIndicator();
73330     } catch (std::out_of_range& e) {
73331       {
73332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73333       };
73334     } catch (std::exception& e) {
73335       {
73336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73337       };
73338     } catch (Dali::DaliException e) {
73339       {
73340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73341       };
73342     } catch (...) {
73343       {
73344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73345       };
73346     }
73347   }
73348
73349 }
73350
73351
73352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73353   void * jresult ;
73354   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73355   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73356
73357   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73358   {
73359     try {
73360       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73361     } catch (std::out_of_range& e) {
73362       {
73363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73364       };
73365     } catch (std::exception& e) {
73366       {
73367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73368       };
73369     } catch (Dali::DaliException e) {
73370       {
73371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73372       };
73373     } catch (...) {
73374       {
73375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73376       };
73377     }
73378   }
73379
73380   jresult = (void *)result;
73381   return jresult;
73382 }
73383
73384
73385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73386   void * jresult ;
73387   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73388   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73389
73390   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73391   {
73392     try {
73393       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73394     } catch (std::out_of_range& e) {
73395       {
73396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73397       };
73398     } catch (std::exception& e) {
73399       {
73400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73401       };
73402     } catch (Dali::DaliException e) {
73403       {
73404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73405       };
73406     } catch (...) {
73407       {
73408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73409       };
73410     }
73411   }
73412
73413   jresult = (void *)result;
73414   return jresult;
73415 }
73416
73417
73418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73419   int jresult ;
73420   int result;
73421
73422   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73423   jresult = (int)result;
73424   return jresult;
73425 }
73426
73427
73428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73429   int jresult ;
73430   int result;
73431
73432   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73433   jresult = (int)result;
73434   return jresult;
73435 }
73436
73437
73438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73439   int jresult ;
73440   int result;
73441
73442   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73443   jresult = (int)result;
73444   return jresult;
73445 }
73446
73447
73448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73449   int jresult ;
73450   int result;
73451
73452   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73453   jresult = (int)result;
73454   return jresult;
73455 }
73456
73457
73458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73459   int jresult ;
73460   int result;
73461
73462   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73463   jresult = (int)result;
73464   return jresult;
73465 }
73466
73467
73468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73469   int jresult ;
73470   int result;
73471
73472   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73473   jresult = (int)result;
73474   return jresult;
73475 }
73476
73477
73478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73479   int jresult ;
73480   int result;
73481
73482   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73483   jresult = (int)result;
73484   return jresult;
73485 }
73486
73487
73488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73489   int jresult ;
73490   int result;
73491
73492   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73493   jresult = (int)result;
73494   return jresult;
73495 }
73496
73497
73498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73499   int jresult ;
73500   int result;
73501
73502   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73503   jresult = (int)result;
73504   return jresult;
73505 }
73506
73507
73508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73509   int jresult ;
73510   int result;
73511
73512   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73513   jresult = (int)result;
73514   return jresult;
73515 }
73516
73517
73518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73519   int jresult ;
73520   int result;
73521
73522   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73523   jresult = (int)result;
73524   return jresult;
73525 }
73526
73527
73528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73529   int jresult ;
73530   int result;
73531
73532   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73533   jresult = (int)result;
73534   return jresult;
73535 }
73536
73537
73538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73539   int jresult ;
73540   int result;
73541
73542   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73543   jresult = (int)result;
73544   return jresult;
73545 }
73546
73547
73548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73549   int jresult ;
73550   int result;
73551
73552   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73553   jresult = (int)result;
73554   return jresult;
73555 }
73556
73557
73558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73559   void * jresult ;
73560   Dali::Toolkit::Scrollable::Property *result = 0 ;
73561
73562   {
73563     try {
73564       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73565     } catch (std::out_of_range& e) {
73566       {
73567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73568       };
73569     } catch (std::exception& e) {
73570       {
73571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73572       };
73573     } catch (Dali::DaliException e) {
73574       {
73575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73576       };
73577     } catch (...) {
73578       {
73579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73580       };
73581     }
73582   }
73583
73584   jresult = (void *)result;
73585   return jresult;
73586 }
73587
73588
73589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73590   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73591
73592   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73593   {
73594     try {
73595       delete arg1;
73596     } catch (std::out_of_range& e) {
73597       {
73598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73599       };
73600     } catch (std::exception& e) {
73601       {
73602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73603       };
73604     } catch (Dali::DaliException e) {
73605       {
73606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73607       };
73608     } catch (...) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73611       };
73612     }
73613   }
73614
73615 }
73616
73617
73618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73619   void * jresult ;
73620   Dali::Toolkit::Scrollable *result = 0 ;
73621
73622   {
73623     try {
73624       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73625     } catch (std::out_of_range& e) {
73626       {
73627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73628       };
73629     } catch (std::exception& e) {
73630       {
73631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73632       };
73633     } catch (Dali::DaliException e) {
73634       {
73635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73636       };
73637     } catch (...) {
73638       {
73639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73640       };
73641     }
73642   }
73643
73644   jresult = (void *)result;
73645   return jresult;
73646 }
73647
73648
73649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73650   void * jresult ;
73651   Dali::Toolkit::Scrollable *arg1 = 0 ;
73652   Dali::Toolkit::Scrollable *result = 0 ;
73653
73654   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73655   if (!arg1) {
73656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73657     return 0;
73658   }
73659   {
73660     try {
73661       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73662     } catch (std::out_of_range& e) {
73663       {
73664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73665       };
73666     } catch (std::exception& e) {
73667       {
73668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73669       };
73670     } catch (Dali::DaliException e) {
73671       {
73672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73673       };
73674     } catch (...) {
73675       {
73676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73677       };
73678     }
73679   }
73680
73681   jresult = (void *)result;
73682   return jresult;
73683 }
73684
73685
73686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73687   void * jresult ;
73688   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73689   Dali::Toolkit::Scrollable *arg2 = 0 ;
73690   Dali::Toolkit::Scrollable *result = 0 ;
73691
73692   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73693   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73694   if (!arg2) {
73695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73696     return 0;
73697   }
73698   {
73699     try {
73700       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73701     } catch (std::out_of_range& e) {
73702       {
73703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73704       };
73705     } catch (std::exception& e) {
73706       {
73707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73708       };
73709     } catch (Dali::DaliException e) {
73710       {
73711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73712       };
73713     } catch (...) {
73714       {
73715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73716       };
73717     }
73718   }
73719
73720   jresult = (void *)result;
73721   return jresult;
73722 }
73723
73724
73725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73726   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73727
73728   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73729   {
73730     try {
73731       delete arg1;
73732     } catch (std::out_of_range& e) {
73733       {
73734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73735       };
73736     } catch (std::exception& e) {
73737       {
73738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73739       };
73740     } catch (Dali::DaliException e) {
73741       {
73742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73743       };
73744     } catch (...) {
73745       {
73746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73747       };
73748     }
73749   }
73750
73751 }
73752
73753
73754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73755   void * jresult ;
73756   Dali::BaseHandle arg1 ;
73757   Dali::BaseHandle *argp1 ;
73758   Dali::Toolkit::Scrollable result;
73759
73760   argp1 = (Dali::BaseHandle *)jarg1;
73761   if (!argp1) {
73762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73763     return 0;
73764   }
73765   arg1 = *argp1;
73766   {
73767     try {
73768       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73769     } catch (std::out_of_range& e) {
73770       {
73771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73772       };
73773     } catch (std::exception& e) {
73774       {
73775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73776       };
73777     } catch (Dali::DaliException e) {
73778       {
73779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73780       };
73781     } catch (...) {
73782       {
73783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73784       };
73785     }
73786   }
73787
73788   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73789   return jresult;
73790 }
73791
73792
73793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
73794   unsigned int jresult ;
73795   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73796   bool result;
73797
73798   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73799   {
73800     try {
73801       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
73802     } catch (std::out_of_range& e) {
73803       {
73804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73805       };
73806     } catch (std::exception& e) {
73807       {
73808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73809       };
73810     } catch (Dali::DaliException e) {
73811       {
73812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73813       };
73814     } catch (...) {
73815       {
73816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73817       };
73818     }
73819   }
73820
73821   jresult = result;
73822   return jresult;
73823 }
73824
73825
73826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
73827   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73828   bool arg2 ;
73829
73830   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73831   arg2 = jarg2 ? true : false;
73832   {
73833     try {
73834       (arg1)->SetOvershootEnabled(arg2);
73835     } catch (std::out_of_range& e) {
73836       {
73837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73838       };
73839     } catch (std::exception& e) {
73840       {
73841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73842       };
73843     } catch (Dali::DaliException e) {
73844       {
73845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73846       };
73847     } catch (...) {
73848       {
73849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73850       };
73851     }
73852   }
73853
73854 }
73855
73856
73857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73858   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73859   Dali::Vector4 *arg2 = 0 ;
73860
73861   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73862   arg2 = (Dali::Vector4 *)jarg2;
73863   if (!arg2) {
73864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73865     return ;
73866   }
73867   {
73868     try {
73869       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73870     } catch (std::out_of_range& e) {
73871       {
73872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73873       };
73874     } catch (std::exception& e) {
73875       {
73876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73877       };
73878     } catch (Dali::DaliException e) {
73879       {
73880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73881       };
73882     } catch (...) {
73883       {
73884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73885       };
73886     }
73887   }
73888
73889 }
73890
73891
73892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73893   void * jresult ;
73894   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73895   Dali::Vector4 result;
73896
73897   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73898   {
73899     try {
73900       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73901     } catch (std::out_of_range& e) {
73902       {
73903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73904       };
73905     } catch (std::exception& e) {
73906       {
73907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73908       };
73909     } catch (Dali::DaliException e) {
73910       {
73911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73912       };
73913     } catch (...) {
73914       {
73915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73916       };
73917     }
73918   }
73919
73920   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73921   return jresult;
73922 }
73923
73924
73925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73926   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73927   float arg2 ;
73928
73929   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73930   arg2 = (float)jarg2;
73931   {
73932     try {
73933       (arg1)->SetOvershootAnimationSpeed(arg2);
73934     } catch (std::out_of_range& e) {
73935       {
73936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73937       };
73938     } catch (std::exception& e) {
73939       {
73940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73941       };
73942     } catch (Dali::DaliException e) {
73943       {
73944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73945       };
73946     } catch (...) {
73947       {
73948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73949       };
73950     }
73951   }
73952
73953 }
73954
73955
73956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73957   float jresult ;
73958   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73959   float result;
73960
73961   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73962   {
73963     try {
73964       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73965     } catch (std::out_of_range& e) {
73966       {
73967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73968       };
73969     } catch (std::exception& e) {
73970       {
73971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73972       };
73973     } catch (Dali::DaliException e) {
73974       {
73975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73976       };
73977     } catch (...) {
73978       {
73979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73980       };
73981     }
73982   }
73983
73984   jresult = result;
73985   return jresult;
73986 }
73987
73988
73989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73990   void * jresult ;
73991   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73992   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73993
73994   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73995   {
73996     try {
73997       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73998     } catch (std::out_of_range& e) {
73999       {
74000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74001       };
74002     } catch (std::exception& e) {
74003       {
74004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74005       };
74006     } catch (Dali::DaliException e) {
74007       {
74008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74009       };
74010     } catch (...) {
74011       {
74012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74013       };
74014     }
74015   }
74016
74017   jresult = (void *)result;
74018   return jresult;
74019 }
74020
74021
74022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74023   void * jresult ;
74024   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74025   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74026
74027   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74028   {
74029     try {
74030       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74031     } catch (std::out_of_range& e) {
74032       {
74033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74034       };
74035     } catch (std::exception& e) {
74036       {
74037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74038       };
74039     } catch (Dali::DaliException e) {
74040       {
74041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74042       };
74043     } catch (...) {
74044       {
74045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74046       };
74047     }
74048   }
74049
74050   jresult = (void *)result;
74051   return jresult;
74052 }
74053
74054
74055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74056   void * jresult ;
74057   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74058   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74059
74060   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74061   {
74062     try {
74063       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74064     } catch (std::out_of_range& e) {
74065       {
74066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74067       };
74068     } catch (std::exception& e) {
74069       {
74070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74071       };
74072     } catch (Dali::DaliException e) {
74073       {
74074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74075       };
74076     } catch (...) {
74077       {
74078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74079       };
74080     }
74081   }
74082
74083   jresult = (void *)result;
74084   return jresult;
74085 }
74086
74087
74088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74089   unsigned int jresult ;
74090   Dali::Toolkit::ControlOrientation::Type arg1 ;
74091   bool result;
74092
74093   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74094   {
74095     try {
74096       result = (bool)Dali::Toolkit::IsVertical(arg1);
74097     } catch (std::out_of_range& e) {
74098       {
74099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74100       };
74101     } catch (std::exception& e) {
74102       {
74103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74104       };
74105     } catch (Dali::DaliException e) {
74106       {
74107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74108       };
74109     } catch (...) {
74110       {
74111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74112       };
74113     }
74114   }
74115
74116   jresult = result;
74117   return jresult;
74118 }
74119
74120
74121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74122   unsigned int jresult ;
74123   Dali::Toolkit::ControlOrientation::Type arg1 ;
74124   bool result;
74125
74126   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74127   {
74128     try {
74129       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74130     } catch (std::out_of_range& e) {
74131       {
74132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74133       };
74134     } catch (std::exception& e) {
74135       {
74136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74137       };
74138     } catch (Dali::DaliException e) {
74139       {
74140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74141       };
74142     } catch (...) {
74143       {
74144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74145       };
74146     }
74147   }
74148
74149   jresult = result;
74150   return jresult;
74151 }
74152
74153
74154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74155   void * jresult ;
74156   unsigned int arg1 ;
74157   unsigned int arg2 ;
74158   Dali::Toolkit::ItemRange *result = 0 ;
74159
74160   arg1 = (unsigned int)jarg1;
74161   arg2 = (unsigned int)jarg2;
74162   {
74163     try {
74164       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74165     } catch (std::out_of_range& e) {
74166       {
74167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74168       };
74169     } catch (std::exception& e) {
74170       {
74171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74172       };
74173     } catch (Dali::DaliException e) {
74174       {
74175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74176       };
74177     } catch (...) {
74178       {
74179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74180       };
74181     }
74182   }
74183
74184   jresult = (void *)result;
74185   return jresult;
74186 }
74187
74188
74189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74190   void * jresult ;
74191   Dali::Toolkit::ItemRange *arg1 = 0 ;
74192   Dali::Toolkit::ItemRange *result = 0 ;
74193
74194   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74195   if (!arg1) {
74196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74197     return 0;
74198   }
74199   {
74200     try {
74201       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74202     } catch (std::out_of_range& e) {
74203       {
74204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74205       };
74206     } catch (std::exception& e) {
74207       {
74208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74209       };
74210     } catch (Dali::DaliException e) {
74211       {
74212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74213       };
74214     } catch (...) {
74215       {
74216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74217       };
74218     }
74219   }
74220
74221   jresult = (void *)result;
74222   return jresult;
74223 }
74224
74225
74226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74227   void * jresult ;
74228   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74229   Dali::Toolkit::ItemRange *arg2 = 0 ;
74230   Dali::Toolkit::ItemRange *result = 0 ;
74231
74232   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74233   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74234   if (!arg2) {
74235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74236     return 0;
74237   }
74238   {
74239     try {
74240       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74241     } catch (std::out_of_range& e) {
74242       {
74243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74244       };
74245     } catch (std::exception& e) {
74246       {
74247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74248       };
74249     } catch (Dali::DaliException e) {
74250       {
74251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74252       };
74253     } catch (...) {
74254       {
74255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74256       };
74257     }
74258   }
74259
74260   jresult = (void *)result;
74261   return jresult;
74262 }
74263
74264
74265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74266   unsigned int jresult ;
74267   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74268   unsigned int arg2 ;
74269   bool result;
74270
74271   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74272   arg2 = (unsigned int)jarg2;
74273   {
74274     try {
74275       result = (bool)(arg1)->Within(arg2);
74276     } catch (std::out_of_range& e) {
74277       {
74278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (std::exception& e) {
74281       {
74282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (Dali::DaliException e) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74287       };
74288     } catch (...) {
74289       {
74290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74291       };
74292     }
74293   }
74294
74295   jresult = result;
74296   return jresult;
74297 }
74298
74299
74300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74301   void * jresult ;
74302   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74303   Dali::Toolkit::ItemRange *arg2 = 0 ;
74304   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74305
74306   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74307   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74308   if (!arg2) {
74309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74310     return 0;
74311   }
74312   {
74313     try {
74314       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74315     } catch (std::out_of_range& e) {
74316       {
74317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74318       };
74319     } catch (std::exception& e) {
74320       {
74321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74322       };
74323     } catch (Dali::DaliException e) {
74324       {
74325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74326       };
74327     } catch (...) {
74328       {
74329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74330       };
74331     }
74332   }
74333
74334   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74335   return jresult;
74336 }
74337
74338
74339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74340   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74341   unsigned int arg2 ;
74342
74343   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74344   arg2 = (unsigned int)jarg2;
74345   if (arg1) (arg1)->begin = arg2;
74346 }
74347
74348
74349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74350   unsigned int jresult ;
74351   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74352   unsigned int result;
74353
74354   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74355   result = (unsigned int) ((arg1)->begin);
74356   jresult = result;
74357   return jresult;
74358 }
74359
74360
74361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74362   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74363   unsigned int arg2 ;
74364
74365   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74366   arg2 = (unsigned int)jarg2;
74367   if (arg1) (arg1)->end = arg2;
74368 }
74369
74370
74371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74372   unsigned int jresult ;
74373   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74374   unsigned int result;
74375
74376   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74377   result = (unsigned int) ((arg1)->end);
74378   jresult = result;
74379   return jresult;
74380 }
74381
74382
74383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74384   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74385
74386   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74387   {
74388     try {
74389       delete arg1;
74390     } catch (std::out_of_range& e) {
74391       {
74392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74393       };
74394     } catch (std::exception& e) {
74395       {
74396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74397       };
74398     } catch (Dali::DaliException e) {
74399       {
74400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74401       };
74402     } catch (...) {
74403       {
74404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74405       };
74406     }
74407   }
74408
74409 }
74410
74411
74412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74413   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74414
74415   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74416   {
74417     try {
74418       delete arg1;
74419     } catch (std::out_of_range& e) {
74420       {
74421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74422       };
74423     } catch (std::exception& e) {
74424       {
74425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74426       };
74427     } catch (Dali::DaliException e) {
74428       {
74429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74430       };
74431     } catch (...) {
74432       {
74433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74434       };
74435     }
74436   }
74437
74438 }
74439
74440
74441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74442   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74443   Dali::Toolkit::ControlOrientation::Type arg2 ;
74444
74445   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74446   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74447   {
74448     try {
74449       (arg1)->SetOrientation(arg2);
74450     } catch (std::out_of_range& e) {
74451       {
74452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74453       };
74454     } catch (std::exception& e) {
74455       {
74456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74457       };
74458     } catch (Dali::DaliException e) {
74459       {
74460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74461       };
74462     } catch (...) {
74463       {
74464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74465       };
74466     }
74467   }
74468
74469 }
74470
74471
74472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74473   int jresult ;
74474   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74475   Dali::Toolkit::ControlOrientation::Type result;
74476
74477   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74478   {
74479     try {
74480       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74481     } catch (std::out_of_range& e) {
74482       {
74483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74484       };
74485     } catch (std::exception& e) {
74486       {
74487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74488       };
74489     } catch (Dali::DaliException e) {
74490       {
74491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74492       };
74493     } catch (...) {
74494       {
74495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74496       };
74497     }
74498   }
74499
74500   jresult = (int)result;
74501   return jresult;
74502 }
74503
74504
74505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74506   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74507   Dali::Property::Map *arg2 = 0 ;
74508
74509   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74510   arg2 = (Dali::Property::Map *)jarg2;
74511   if (!arg2) {
74512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74513     return ;
74514   }
74515   {
74516     try {
74517       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74518     } catch (std::out_of_range& e) {
74519       {
74520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74521       };
74522     } catch (std::exception& e) {
74523       {
74524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74525       };
74526     } catch (Dali::DaliException e) {
74527       {
74528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74529       };
74530     } catch (...) {
74531       {
74532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74533       };
74534     }
74535   }
74536
74537 }
74538
74539
74540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74541   void * jresult ;
74542   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74543   Dali::Property::Map result;
74544
74545   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74546   {
74547     try {
74548       result = (arg1)->GetLayoutProperties();
74549     } catch (std::out_of_range& e) {
74550       {
74551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74552       };
74553     } catch (std::exception& e) {
74554       {
74555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74556       };
74557     } catch (Dali::DaliException e) {
74558       {
74559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74560       };
74561     } catch (...) {
74562       {
74563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74564       };
74565     }
74566   }
74567
74568   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74569   return jresult;
74570 }
74571
74572
74573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74574   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74575   unsigned int arg2 ;
74576   Dali::Vector3 *arg3 = 0 ;
74577   Dali::Vector3 *arg4 = 0 ;
74578
74579   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74580   arg2 = (unsigned int)jarg2;
74581   arg3 = (Dali::Vector3 *)jarg3;
74582   if (!arg3) {
74583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74584     return ;
74585   }
74586   arg4 = (Dali::Vector3 *)jarg4;
74587   if (!arg4) {
74588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74589     return ;
74590   }
74591   {
74592     try {
74593       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74594     } catch (std::out_of_range& e) {
74595       {
74596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74597       };
74598     } catch (std::exception& e) {
74599       {
74600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74601       };
74602     } catch (Dali::DaliException e) {
74603       {
74604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74605       };
74606     } catch (...) {
74607       {
74608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74609       };
74610     }
74611   }
74612
74613 }
74614
74615
74616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74617   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74618   Dali::Vector3 *arg2 = 0 ;
74619
74620   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74621   arg2 = (Dali::Vector3 *)jarg2;
74622   if (!arg2) {
74623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74624     return ;
74625   }
74626   {
74627     try {
74628       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74629     } catch (std::out_of_range& e) {
74630       {
74631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74632       };
74633     } catch (std::exception& e) {
74634       {
74635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74636       };
74637     } catch (Dali::DaliException e) {
74638       {
74639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74640       };
74641     } catch (...) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74644       };
74645     }
74646   }
74647
74648 }
74649
74650
74651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74652   float jresult ;
74653   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74654   unsigned int arg2 ;
74655   Dali::Vector3 arg3 ;
74656   Dali::Vector3 *argp3 ;
74657   float result;
74658
74659   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74660   arg2 = (unsigned int)jarg2;
74661   argp3 = (Dali::Vector3 *)jarg3;
74662   if (!argp3) {
74663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74664     return 0;
74665   }
74666   arg3 = *argp3;
74667   {
74668     try {
74669       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74670     } catch (std::out_of_range& e) {
74671       {
74672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74673       };
74674     } catch (std::exception& e) {
74675       {
74676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74677       };
74678     } catch (Dali::DaliException e) {
74679       {
74680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74681       };
74682     } catch (...) {
74683       {
74684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74685       };
74686     }
74687   }
74688
74689   jresult = result;
74690   return jresult;
74691 }
74692
74693
74694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74695   float jresult ;
74696   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74697   float arg2 ;
74698   float result;
74699
74700   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74701   arg2 = (float)jarg2;
74702   {
74703     try {
74704       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74705     } catch (std::out_of_range& e) {
74706       {
74707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74708       };
74709     } catch (std::exception& e) {
74710       {
74711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74712       };
74713     } catch (Dali::DaliException e) {
74714       {
74715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74716       };
74717     } catch (...) {
74718       {
74719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74720       };
74721     }
74722   }
74723
74724   jresult = result;
74725   return jresult;
74726 }
74727
74728
74729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74730   float jresult ;
74731   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74732   unsigned int arg2 ;
74733   float result;
74734
74735   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74736   arg2 = (unsigned int)jarg2;
74737   {
74738     try {
74739       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74740     } catch (std::out_of_range& e) {
74741       {
74742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74743       };
74744     } catch (std::exception& e) {
74745       {
74746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74747       };
74748     } catch (Dali::DaliException e) {
74749       {
74750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74751       };
74752     } catch (...) {
74753       {
74754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74755       };
74756     }
74757   }
74758
74759   jresult = result;
74760   return jresult;
74761 }
74762
74763
74764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74765   void * jresult ;
74766   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74767   float arg2 ;
74768   Dali::Vector3 arg3 ;
74769   Dali::Vector3 *argp3 ;
74770   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74771
74772   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74773   arg2 = (float)jarg2;
74774   argp3 = (Dali::Vector3 *)jarg3;
74775   if (!argp3) {
74776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74777     return 0;
74778   }
74779   arg3 = *argp3;
74780   {
74781     try {
74782       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74783     } catch (std::out_of_range& e) {
74784       {
74785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74786       };
74787     } catch (std::exception& e) {
74788       {
74789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74790       };
74791     } catch (Dali::DaliException e) {
74792       {
74793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74794       };
74795     } catch (...) {
74796       {
74797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74798       };
74799     }
74800   }
74801
74802   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74803   return jresult;
74804 }
74805
74806
74807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74808   float jresult ;
74809   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74810   int arg2 ;
74811   float arg3 ;
74812   Dali::Vector3 *arg4 = 0 ;
74813   float result;
74814
74815   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74816   arg2 = (int)jarg2;
74817   arg3 = (float)jarg3;
74818   arg4 = (Dali::Vector3 *)jarg4;
74819   if (!arg4) {
74820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74821     return 0;
74822   }
74823   {
74824     try {
74825       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74826     } catch (std::out_of_range& e) {
74827       {
74828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74829       };
74830     } catch (std::exception& e) {
74831       {
74832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74833       };
74834     } catch (Dali::DaliException e) {
74835       {
74836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74837       };
74838     } catch (...) {
74839       {
74840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74841       };
74842     }
74843   }
74844
74845   jresult = result;
74846   return jresult;
74847 }
74848
74849
74850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74851   unsigned int jresult ;
74852   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74853   Dali::Vector3 arg2 ;
74854   Dali::Vector3 *argp2 ;
74855   unsigned int result;
74856
74857   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74858   argp2 = (Dali::Vector3 *)jarg2;
74859   if (!argp2) {
74860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74861     return 0;
74862   }
74863   arg2 = *argp2;
74864   {
74865     try {
74866       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74867     } catch (std::out_of_range& e) {
74868       {
74869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74870       };
74871     } catch (std::exception& e) {
74872       {
74873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74874       };
74875     } catch (Dali::DaliException e) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74878       };
74879     } catch (...) {
74880       {
74881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74882       };
74883     }
74884   }
74885
74886   jresult = result;
74887   return jresult;
74888 }
74889
74890
74891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74892   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74893   unsigned int arg2 ;
74894   Dali::Vector3 *arg3 = 0 ;
74895   Dali::Vector3 *arg4 = 0 ;
74896
74897   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74898   arg2 = (unsigned int)jarg2;
74899   arg3 = (Dali::Vector3 *)jarg3;
74900   if (!arg3) {
74901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74902     return ;
74903   }
74904   arg4 = (Dali::Vector3 *)jarg4;
74905   if (!arg4) {
74906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74907     return ;
74908   }
74909   {
74910     try {
74911       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74912     } catch (std::out_of_range& e) {
74913       {
74914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74915       };
74916     } catch (std::exception& e) {
74917       {
74918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74919       };
74920     } catch (Dali::DaliException e) {
74921       {
74922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74923       };
74924     } catch (...) {
74925       {
74926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74927       };
74928     }
74929   }
74930
74931 }
74932
74933
74934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74935   void * jresult ;
74936   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74937   Dali::Degree result;
74938
74939   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74940   {
74941     try {
74942       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74943     } catch (std::out_of_range& e) {
74944       {
74945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74946       };
74947     } catch (std::exception& e) {
74948       {
74949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74950       };
74951     } catch (Dali::DaliException e) {
74952       {
74953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74954       };
74955     } catch (...) {
74956       {
74957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74958       };
74959     }
74960   }
74961
74962   jresult = new Dali::Degree((const Dali::Degree &)result);
74963   return jresult;
74964 }
74965
74966
74967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74968   float jresult ;
74969   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74970   float result;
74971
74972   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74973   {
74974     try {
74975       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74976     } catch (std::out_of_range& e) {
74977       {
74978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74979       };
74980     } catch (std::exception& e) {
74981       {
74982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74983       };
74984     } catch (Dali::DaliException e) {
74985       {
74986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74987       };
74988     } catch (...) {
74989       {
74990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74991       };
74992     }
74993   }
74994
74995   jresult = result;
74996   return jresult;
74997 }
74998
74999
75000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75001   float jresult ;
75002   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75003   float result;
75004
75005   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75006   {
75007     try {
75008       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75009     } catch (std::out_of_range& e) {
75010       {
75011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75012       };
75013     } catch (std::exception& e) {
75014       {
75015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75016       };
75017     } catch (Dali::DaliException e) {
75018       {
75019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75020       };
75021     } catch (...) {
75022       {
75023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75024       };
75025     }
75026   }
75027
75028   jresult = result;
75029   return jresult;
75030 }
75031
75032
75033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75034   float jresult ;
75035   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75036   float result;
75037
75038   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75039   {
75040     try {
75041       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75042     } catch (std::out_of_range& e) {
75043       {
75044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75045       };
75046     } catch (std::exception& e) {
75047       {
75048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75049       };
75050     } catch (Dali::DaliException e) {
75051       {
75052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75053       };
75054     } catch (...) {
75055       {
75056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75057       };
75058     }
75059   }
75060
75061   jresult = result;
75062   return jresult;
75063 }
75064
75065
75066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75067   int jresult ;
75068   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75069   int arg2 ;
75070   int arg3 ;
75071   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75072   bool arg5 ;
75073   int result;
75074
75075   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75076   arg2 = (int)jarg2;
75077   arg3 = (int)jarg3;
75078   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75079   arg5 = jarg5 ? true : false;
75080   {
75081     try {
75082       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75083     } catch (std::out_of_range& e) {
75084       {
75085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75086       };
75087     } catch (std::exception& e) {
75088       {
75089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75090       };
75091     } catch (Dali::DaliException e) {
75092       {
75093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75094       };
75095     } catch (...) {
75096       {
75097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75098       };
75099     }
75100   }
75101
75102   jresult = result;
75103   return jresult;
75104 }
75105
75106
75107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75108   float jresult ;
75109   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75110   float result;
75111
75112   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75113   {
75114     try {
75115       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75116     } catch (std::out_of_range& e) {
75117       {
75118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75119       };
75120     } catch (std::exception& e) {
75121       {
75122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75123       };
75124     } catch (Dali::DaliException e) {
75125       {
75126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75127       };
75128     } catch (...) {
75129       {
75130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75131       };
75132     }
75133   }
75134
75135   jresult = result;
75136   return jresult;
75137 }
75138
75139
75140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75141   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75142   Dali::Actor *arg2 = 0 ;
75143   int arg3 ;
75144   Dali::Vector3 *arg4 = 0 ;
75145   Dali::Actor *arg5 = 0 ;
75146
75147   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75148   arg2 = (Dali::Actor *)jarg2;
75149   if (!arg2) {
75150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75151     return ;
75152   }
75153   arg3 = (int)jarg3;
75154   arg4 = (Dali::Vector3 *)jarg4;
75155   if (!arg4) {
75156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75157     return ;
75158   }
75159   arg5 = (Dali::Actor *)jarg5;
75160   if (!arg5) {
75161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75162     return ;
75163   }
75164   {
75165     try {
75166       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75167     } catch (std::out_of_range& e) {
75168       {
75169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75170       };
75171     } catch (std::exception& e) {
75172       {
75173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (Dali::DaliException e) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75178       };
75179     } catch (...) {
75180       {
75181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75182       };
75183     }
75184   }
75185
75186 }
75187
75188
75189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75190   void * jresult ;
75191   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75192   int arg2 ;
75193   float arg3 ;
75194   Dali::Vector3 *arg4 = 0 ;
75195   Dali::Vector3 result;
75196
75197   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75198   arg2 = (int)jarg2;
75199   arg3 = (float)jarg3;
75200   arg4 = (Dali::Vector3 *)jarg4;
75201   if (!arg4) {
75202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75203     return 0;
75204   }
75205   {
75206     try {
75207       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75208     } catch (std::out_of_range& e) {
75209       {
75210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75211       };
75212     } catch (std::exception& e) {
75213       {
75214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75215       };
75216     } catch (Dali::DaliException e) {
75217       {
75218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75219       };
75220     } catch (...) {
75221       {
75222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75223       };
75224     }
75225   }
75226
75227   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75228   return jresult;
75229 }
75230
75231
75232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75233   void * jresult ;
75234   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75235   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75236
75237   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75238   {
75239     try {
75240       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75241     } catch (std::out_of_range& e) {
75242       {
75243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75244       };
75245     } catch (std::exception& e) {
75246       {
75247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75248       };
75249     } catch (Dali::DaliException e) {
75250       {
75251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75252       };
75253     } catch (...) {
75254       {
75255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75256       };
75257     }
75258   }
75259
75260   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75261   return jresult;
75262 }
75263
75264
75265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75266   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75267
75268   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75269   {
75270     try {
75271       delete arg1;
75272     } catch (std::out_of_range& e) {
75273       {
75274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75275       };
75276     } catch (std::exception& e) {
75277       {
75278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75279       };
75280     } catch (Dali::DaliException e) {
75281       {
75282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75283       };
75284     } catch (...) {
75285       {
75286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75287       };
75288     }
75289   }
75290
75291 }
75292
75293
75294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75295   unsigned int jresult ;
75296   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75297   unsigned int result;
75298
75299   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75300   {
75301     try {
75302       result = (unsigned int)(arg1)->GetNumberOfItems();
75303     } catch (std::out_of_range& e) {
75304       {
75305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75306       };
75307     } catch (std::exception& e) {
75308       {
75309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75310       };
75311     } catch (Dali::DaliException e) {
75312       {
75313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75314       };
75315     } catch (...) {
75316       {
75317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75318       };
75319     }
75320   }
75321
75322   jresult = result;
75323   return jresult;
75324 }
75325
75326
75327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75328   void * jresult ;
75329   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75330   unsigned int arg2 ;
75331   Dali::Actor result;
75332
75333   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75334   arg2 = (unsigned int)jarg2;
75335   {
75336     try {
75337       result = (arg1)->NewItem(arg2);
75338     } catch (std::out_of_range& e) {
75339       {
75340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75341       };
75342     } catch (std::exception& e) {
75343       {
75344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75345       };
75346     } catch (Dali::DaliException e) {
75347       {
75348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75349       };
75350     } catch (...) {
75351       {
75352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75353       };
75354     }
75355   }
75356
75357   jresult = new Dali::Actor((const Dali::Actor &)result);
75358   return jresult;
75359 }
75360
75361
75362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75363   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75364   unsigned int arg2 ;
75365   Dali::Actor arg3 ;
75366   Dali::Actor *argp3 ;
75367
75368   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75369   arg2 = (unsigned int)jarg2;
75370   argp3 = (Dali::Actor *)jarg3;
75371   if (!argp3) {
75372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75373     return ;
75374   }
75375   arg3 = *argp3;
75376   {
75377     try {
75378       (arg1)->ItemReleased(arg2,arg3);
75379     } catch (std::out_of_range& e) {
75380       {
75381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75382       };
75383     } catch (std::exception& e) {
75384       {
75385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75386       };
75387     } catch (Dali::DaliException e) {
75388       {
75389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75390       };
75391     } catch (...) {
75392       {
75393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75394       };
75395     }
75396   }
75397
75398 }
75399
75400
75401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75402   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75403   unsigned int arg2 ;
75404   Dali::Actor arg3 ;
75405   Dali::Actor *argp3 ;
75406
75407   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75408   arg2 = (unsigned int)jarg2;
75409   argp3 = (Dali::Actor *)jarg3;
75410   if (!argp3) {
75411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75412     return ;
75413   }
75414   arg3 = *argp3;
75415   {
75416     try {
75417       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75418     } catch (std::out_of_range& e) {
75419       {
75420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75421       };
75422     } catch (std::exception& e) {
75423       {
75424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75425       };
75426     } catch (Dali::DaliException e) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75429       };
75430     } catch (...) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75433       };
75434     }
75435   }
75436
75437 }
75438
75439
75440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75441   void * jresult ;
75442   Dali::Toolkit::ItemFactory *result = 0 ;
75443
75444   {
75445     try {
75446       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75447     } catch (std::out_of_range& e) {
75448       {
75449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75450       };
75451     } catch (std::exception& e) {
75452       {
75453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75454       };
75455     } catch (Dali::DaliException e) {
75456       {
75457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75458       };
75459     } catch (...) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75462       };
75463     }
75464   }
75465
75466   jresult = (void *)result;
75467   return jresult;
75468 }
75469
75470
75471 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) {
75472   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75473   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75474   if (director) {
75475     director->swig_connect_director(callback0, callback1, callback2);
75476   }
75477 }
75478
75479
75480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75481   int jresult ;
75482   int result;
75483
75484   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75485   jresult = (int)result;
75486   return jresult;
75487 }
75488
75489
75490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75491   int jresult ;
75492   int result;
75493
75494   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75495   jresult = (int)result;
75496   return jresult;
75497 }
75498
75499
75500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75501   int jresult ;
75502   int result;
75503
75504   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75505   jresult = (int)result;
75506   return jresult;
75507 }
75508
75509
75510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75511   int jresult ;
75512   int result;
75513
75514   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75515   jresult = (int)result;
75516   return jresult;
75517 }
75518
75519
75520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75521   int jresult ;
75522   int result;
75523
75524   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75525   jresult = (int)result;
75526   return jresult;
75527 }
75528
75529
75530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75531   int jresult ;
75532   int result;
75533
75534   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75535   jresult = (int)result;
75536   return jresult;
75537 }
75538
75539
75540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75541   int jresult ;
75542   int result;
75543
75544   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75545   jresult = (int)result;
75546   return jresult;
75547 }
75548
75549
75550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75551   int jresult ;
75552   int result;
75553
75554   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75555   jresult = (int)result;
75556   return jresult;
75557 }
75558
75559
75560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75561   int jresult ;
75562   int result;
75563
75564   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75565   jresult = (int)result;
75566   return jresult;
75567 }
75568
75569
75570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75571   int jresult ;
75572   int result;
75573
75574   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75575   jresult = (int)result;
75576   return jresult;
75577 }
75578
75579
75580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75581   int jresult ;
75582   int result;
75583
75584   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75585   jresult = (int)result;
75586   return jresult;
75587 }
75588
75589
75590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75591   void * jresult ;
75592   Dali::Toolkit::ItemView::Property *result = 0 ;
75593
75594   {
75595     try {
75596       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75597     } catch (std::out_of_range& e) {
75598       {
75599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75600       };
75601     } catch (std::exception& e) {
75602       {
75603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75604       };
75605     } catch (Dali::DaliException e) {
75606       {
75607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75608       };
75609     } catch (...) {
75610       {
75611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75612       };
75613     }
75614   }
75615
75616   jresult = (void *)result;
75617   return jresult;
75618 }
75619
75620
75621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75622   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75623
75624   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75625   {
75626     try {
75627       delete arg1;
75628     } catch (std::out_of_range& e) {
75629       {
75630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75631       };
75632     } catch (std::exception& e) {
75633       {
75634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75635       };
75636     } catch (Dali::DaliException e) {
75637       {
75638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75639       };
75640     } catch (...) {
75641       {
75642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75643       };
75644     }
75645   }
75646
75647 }
75648
75649
75650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75651   void * jresult ;
75652   Dali::Toolkit::ItemView *result = 0 ;
75653
75654   {
75655     try {
75656       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75657     } catch (std::out_of_range& e) {
75658       {
75659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75660       };
75661     } catch (std::exception& e) {
75662       {
75663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75664       };
75665     } catch (Dali::DaliException e) {
75666       {
75667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75668       };
75669     } catch (...) {
75670       {
75671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75672       };
75673     }
75674   }
75675
75676   jresult = (void *)result;
75677   return jresult;
75678 }
75679
75680
75681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75682   void * jresult ;
75683   Dali::Toolkit::ItemView *arg1 = 0 ;
75684   Dali::Toolkit::ItemView *result = 0 ;
75685
75686   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75687   if (!arg1) {
75688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75689     return 0;
75690   }
75691   {
75692     try {
75693       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75694     } catch (std::out_of_range& e) {
75695       {
75696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75697       };
75698     } catch (std::exception& e) {
75699       {
75700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75701       };
75702     } catch (Dali::DaliException e) {
75703       {
75704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75705       };
75706     } catch (...) {
75707       {
75708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75709       };
75710     }
75711   }
75712
75713   jresult = (void *)result;
75714   return jresult;
75715 }
75716
75717
75718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75719   void * jresult ;
75720   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75721   Dali::Toolkit::ItemView *arg2 = 0 ;
75722   Dali::Toolkit::ItemView *result = 0 ;
75723
75724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75725   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75726   if (!arg2) {
75727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75728     return 0;
75729   }
75730   {
75731     try {
75732       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75733     } catch (std::out_of_range& e) {
75734       {
75735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75736       };
75737     } catch (std::exception& e) {
75738       {
75739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75740       };
75741     } catch (Dali::DaliException e) {
75742       {
75743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75744       };
75745     } catch (...) {
75746       {
75747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75748       };
75749     }
75750   }
75751
75752   jresult = (void *)result;
75753   return jresult;
75754 }
75755
75756
75757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75758   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75759
75760   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75761   {
75762     try {
75763       delete arg1;
75764     } catch (std::out_of_range& e) {
75765       {
75766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75767       };
75768     } catch (std::exception& e) {
75769       {
75770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75771       };
75772     } catch (Dali::DaliException e) {
75773       {
75774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75775       };
75776     } catch (...) {
75777       {
75778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75779       };
75780     }
75781   }
75782
75783 }
75784
75785
75786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75787   void * jresult ;
75788   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75789   Dali::Toolkit::ItemView result;
75790
75791   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75792   if (!arg1) {
75793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
75794     return 0;
75795   }
75796   {
75797     try {
75798       result = Dali::Toolkit::ItemView::New(*arg1);
75799     } catch (std::out_of_range& e) {
75800       {
75801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75802       };
75803     } catch (std::exception& e) {
75804       {
75805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75806       };
75807     } catch (Dali::DaliException e) {
75808       {
75809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75810       };
75811     } catch (...) {
75812       {
75813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75814       };
75815     }
75816   }
75817
75818   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75819   return jresult;
75820 }
75821
75822
75823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
75824   void * jresult ;
75825   Dali::BaseHandle arg1 ;
75826   Dali::BaseHandle *argp1 ;
75827   Dali::Toolkit::ItemView result;
75828
75829   argp1 = (Dali::BaseHandle *)jarg1;
75830   if (!argp1) {
75831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75832     return 0;
75833   }
75834   arg1 = *argp1;
75835   {
75836     try {
75837       result = Dali::Toolkit::ItemView::DownCast(arg1);
75838     } catch (std::out_of_range& e) {
75839       {
75840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75841       };
75842     } catch (std::exception& e) {
75843       {
75844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75845       };
75846     } catch (Dali::DaliException e) {
75847       {
75848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75849       };
75850     } catch (...) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75853       };
75854     }
75855   }
75856
75857   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75858   return jresult;
75859 }
75860
75861
75862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75863   unsigned int jresult ;
75864   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75865   unsigned int result;
75866
75867   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75868   {
75869     try {
75870       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75871     } catch (std::out_of_range& e) {
75872       {
75873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75874       };
75875     } catch (std::exception& e) {
75876       {
75877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75878       };
75879     } catch (Dali::DaliException e) {
75880       {
75881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75882       };
75883     } catch (...) {
75884       {
75885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75886       };
75887     }
75888   }
75889
75890   jresult = result;
75891   return jresult;
75892 }
75893
75894
75895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75896   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75897   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75898
75899   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75900   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75901   if (!arg2) {
75902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75903     return ;
75904   }
75905   {
75906     try {
75907       (arg1)->AddLayout(*arg2);
75908     } catch (std::out_of_range& e) {
75909       {
75910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75911       };
75912     } catch (std::exception& e) {
75913       {
75914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75915       };
75916     } catch (Dali::DaliException e) {
75917       {
75918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75919       };
75920     } catch (...) {
75921       {
75922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75923       };
75924     }
75925   }
75926
75927 }
75928
75929
75930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75931   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75932   unsigned int arg2 ;
75933
75934   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75935   arg2 = (unsigned int)jarg2;
75936   {
75937     try {
75938       (arg1)->RemoveLayout(arg2);
75939     } catch (std::out_of_range& e) {
75940       {
75941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75942       };
75943     } catch (std::exception& e) {
75944       {
75945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75946       };
75947     } catch (Dali::DaliException e) {
75948       {
75949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75950       };
75951     } catch (...) {
75952       {
75953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75954       };
75955     }
75956   }
75957
75958 }
75959
75960
75961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75962   void * jresult ;
75963   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75964   unsigned int arg2 ;
75965   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75966
75967   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75968   arg2 = (unsigned int)jarg2;
75969   {
75970     try {
75971       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75972     } catch (std::out_of_range& e) {
75973       {
75974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75975       };
75976     } catch (std::exception& e) {
75977       {
75978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75979       };
75980     } catch (Dali::DaliException e) {
75981       {
75982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75983       };
75984     } catch (...) {
75985       {
75986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75987       };
75988     }
75989   }
75990
75991   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75992   return jresult;
75993 }
75994
75995
75996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75997   void * jresult ;
75998   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75999   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76000
76001   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76002   {
76003     try {
76004       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76005     } catch (std::out_of_range& e) {
76006       {
76007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76008       };
76009     } catch (std::exception& e) {
76010       {
76011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76012       };
76013     } catch (Dali::DaliException e) {
76014       {
76015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76016       };
76017     } catch (...) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76020       };
76021     }
76022   }
76023
76024   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76025   return jresult;
76026 }
76027
76028
76029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76030   float jresult ;
76031   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76032   Dali::Toolkit::ItemId arg2 ;
76033   float result;
76034
76035   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76036   arg2 = (Dali::Toolkit::ItemId)jarg2;
76037   {
76038     try {
76039       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76040     } catch (std::out_of_range& e) {
76041       {
76042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76043       };
76044     } catch (std::exception& e) {
76045       {
76046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76047       };
76048     } catch (Dali::DaliException e) {
76049       {
76050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76051       };
76052     } catch (...) {
76053       {
76054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76055       };
76056     }
76057   }
76058
76059   jresult = result;
76060   return jresult;
76061 }
76062
76063
76064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76065   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76066   unsigned int arg2 ;
76067   Dali::Vector3 arg3 ;
76068   float arg4 ;
76069   Dali::Vector3 *argp3 ;
76070
76071   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76072   arg2 = (unsigned int)jarg2;
76073   argp3 = (Dali::Vector3 *)jarg3;
76074   if (!argp3) {
76075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76076     return ;
76077   }
76078   arg3 = *argp3;
76079   arg4 = (float)jarg4;
76080   {
76081     try {
76082       (arg1)->ActivateLayout(arg2,arg3,arg4);
76083     } catch (std::out_of_range& e) {
76084       {
76085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76086       };
76087     } catch (std::exception& e) {
76088       {
76089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76090       };
76091     } catch (Dali::DaliException e) {
76092       {
76093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76094       };
76095     } catch (...) {
76096       {
76097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76098       };
76099     }
76100   }
76101
76102 }
76103
76104
76105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76106   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76107
76108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76109   {
76110     try {
76111       (arg1)->DeactivateCurrentLayout();
76112     } catch (std::out_of_range& e) {
76113       {
76114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76115       };
76116     } catch (std::exception& e) {
76117       {
76118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76119       };
76120     } catch (Dali::DaliException e) {
76121       {
76122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76123       };
76124     } catch (...) {
76125       {
76126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76127       };
76128     }
76129   }
76130
76131 }
76132
76133
76134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76135   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76136   float arg2 ;
76137
76138   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76139   arg2 = (float)jarg2;
76140   {
76141     try {
76142       (arg1)->SetMinimumSwipeSpeed(arg2);
76143     } catch (std::out_of_range& e) {
76144       {
76145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76146       };
76147     } catch (std::exception& e) {
76148       {
76149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76150       };
76151     } catch (Dali::DaliException e) {
76152       {
76153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76154       };
76155     } catch (...) {
76156       {
76157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76158       };
76159     }
76160   }
76161
76162 }
76163
76164
76165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76166   float jresult ;
76167   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76168   float result;
76169
76170   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76171   {
76172     try {
76173       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76174     } catch (std::out_of_range& e) {
76175       {
76176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76177       };
76178     } catch (std::exception& e) {
76179       {
76180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76181       };
76182     } catch (Dali::DaliException e) {
76183       {
76184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76185       };
76186     } catch (...) {
76187       {
76188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76189       };
76190     }
76191   }
76192
76193   jresult = result;
76194   return jresult;
76195 }
76196
76197
76198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76199   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76200   float arg2 ;
76201
76202   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76203   arg2 = (float)jarg2;
76204   {
76205     try {
76206       (arg1)->SetMinimumSwipeDistance(arg2);
76207     } catch (std::out_of_range& e) {
76208       {
76209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76210       };
76211     } catch (std::exception& e) {
76212       {
76213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76214       };
76215     } catch (Dali::DaliException e) {
76216       {
76217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76218       };
76219     } catch (...) {
76220       {
76221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76222       };
76223     }
76224   }
76225
76226 }
76227
76228
76229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76230   float jresult ;
76231   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76232   float result;
76233
76234   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76235   {
76236     try {
76237       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76238     } catch (std::out_of_range& e) {
76239       {
76240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76241       };
76242     } catch (std::exception& e) {
76243       {
76244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76245       };
76246     } catch (Dali::DaliException e) {
76247       {
76248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76249       };
76250     } catch (...) {
76251       {
76252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76253       };
76254     }
76255   }
76256
76257   jresult = result;
76258   return jresult;
76259 }
76260
76261
76262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76263   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76264   float arg2 ;
76265
76266   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76267   arg2 = (float)jarg2;
76268   {
76269     try {
76270       (arg1)->SetWheelScrollDistanceStep(arg2);
76271     } catch (std::out_of_range& e) {
76272       {
76273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76274       };
76275     } catch (std::exception& e) {
76276       {
76277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76278       };
76279     } catch (Dali::DaliException e) {
76280       {
76281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76282       };
76283     } catch (...) {
76284       {
76285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76286       };
76287     }
76288   }
76289
76290 }
76291
76292
76293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76294   float jresult ;
76295   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76296   float result;
76297
76298   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76299   {
76300     try {
76301       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76302     } catch (std::out_of_range& e) {
76303       {
76304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76305       };
76306     } catch (std::exception& e) {
76307       {
76308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76309       };
76310     } catch (Dali::DaliException e) {
76311       {
76312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76313       };
76314     } catch (...) {
76315       {
76316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76317       };
76318     }
76319   }
76320
76321   jresult = result;
76322   return jresult;
76323 }
76324
76325
76326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76327   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76328   bool arg2 ;
76329
76330   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76331   arg2 = jarg2 ? true : false;
76332   {
76333     try {
76334       (arg1)->SetAnchoring(arg2);
76335     } catch (std::out_of_range& e) {
76336       {
76337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76338       };
76339     } catch (std::exception& e) {
76340       {
76341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76342       };
76343     } catch (Dali::DaliException e) {
76344       {
76345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76346       };
76347     } catch (...) {
76348       {
76349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76350       };
76351     }
76352   }
76353
76354 }
76355
76356 //// ========================= end of part 3 =============================
76357
76358 //// ========================== start part 4 ===============================
76359
76360
76361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76362   unsigned int jresult ;
76363   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76364   bool result;
76365
76366   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76367   {
76368     try {
76369       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76370     } catch (std::out_of_range& e) {
76371       {
76372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76373       };
76374     } catch (std::exception& e) {
76375       {
76376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76377       };
76378     } catch (Dali::DaliException e) {
76379       {
76380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76381       };
76382     } catch (...) {
76383       {
76384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76385       };
76386     }
76387   }
76388
76389   jresult = result;
76390   return jresult;
76391 }
76392
76393
76394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76395   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76396   float arg2 ;
76397
76398   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76399   arg2 = (float)jarg2;
76400   {
76401     try {
76402       (arg1)->SetAnchoringDuration(arg2);
76403     } catch (std::out_of_range& e) {
76404       {
76405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76406       };
76407     } catch (std::exception& e) {
76408       {
76409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76410       };
76411     } catch (Dali::DaliException e) {
76412       {
76413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76414       };
76415     } catch (...) {
76416       {
76417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76418       };
76419     }
76420   }
76421
76422 }
76423
76424
76425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76426   float jresult ;
76427   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76428   float result;
76429
76430   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76431   {
76432     try {
76433       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76434     } catch (std::out_of_range& e) {
76435       {
76436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76437       };
76438     } catch (std::exception& e) {
76439       {
76440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76441       };
76442     } catch (Dali::DaliException e) {
76443       {
76444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76445       };
76446     } catch (...) {
76447       {
76448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76449       };
76450     }
76451   }
76452
76453   jresult = result;
76454   return jresult;
76455 }
76456
76457
76458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76459   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76460   Dali::Toolkit::ItemId arg2 ;
76461   float arg3 ;
76462
76463   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76464   arg2 = (Dali::Toolkit::ItemId)jarg2;
76465   arg3 = (float)jarg3;
76466   {
76467     try {
76468       (arg1)->ScrollToItem(arg2,arg3);
76469     } catch (std::out_of_range& e) {
76470       {
76471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76472       };
76473     } catch (std::exception& e) {
76474       {
76475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76476       };
76477     } catch (Dali::DaliException e) {
76478       {
76479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76480       };
76481     } catch (...) {
76482       {
76483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76484       };
76485     }
76486   }
76487
76488 }
76489
76490
76491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76492   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76493   float arg2 ;
76494
76495   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76496   arg2 = (float)jarg2;
76497   {
76498     try {
76499       (arg1)->SetRefreshInterval(arg2);
76500     } catch (std::out_of_range& e) {
76501       {
76502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76503       };
76504     } catch (std::exception& e) {
76505       {
76506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76507       };
76508     } catch (Dali::DaliException e) {
76509       {
76510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76511       };
76512     } catch (...) {
76513       {
76514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76515       };
76516     }
76517   }
76518
76519 }
76520
76521
76522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76523   float jresult ;
76524   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76525   float result;
76526
76527   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76528   {
76529     try {
76530       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76531     } catch (std::out_of_range& e) {
76532       {
76533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76534       };
76535     } catch (std::exception& e) {
76536       {
76537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76538       };
76539     } catch (Dali::DaliException e) {
76540       {
76541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76542       };
76543     } catch (...) {
76544       {
76545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76546       };
76547     }
76548   }
76549
76550   jresult = result;
76551   return jresult;
76552 }
76553
76554
76555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76556   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76557
76558   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76559   {
76560     try {
76561       (arg1)->Refresh();
76562     } catch (std::out_of_range& e) {
76563       {
76564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76565       };
76566     } catch (std::exception& e) {
76567       {
76568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76569       };
76570     } catch (Dali::DaliException e) {
76571       {
76572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76573       };
76574     } catch (...) {
76575       {
76576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76577       };
76578     }
76579   }
76580
76581 }
76582
76583
76584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76585   void * jresult ;
76586   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76587   Dali::Toolkit::ItemId arg2 ;
76588   Dali::Actor result;
76589
76590   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76591   arg2 = (Dali::Toolkit::ItemId)jarg2;
76592   {
76593     try {
76594       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76595     } catch (std::out_of_range& e) {
76596       {
76597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76598       };
76599     } catch (std::exception& e) {
76600       {
76601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76602       };
76603     } catch (Dali::DaliException e) {
76604       {
76605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76606       };
76607     } catch (...) {
76608       {
76609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76610       };
76611     }
76612   }
76613
76614   jresult = new Dali::Actor((const Dali::Actor &)result);
76615   return jresult;
76616 }
76617
76618
76619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76620   unsigned int jresult ;
76621   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76622   Dali::Actor arg2 ;
76623   Dali::Actor *argp2 ;
76624   Dali::Toolkit::ItemId result;
76625
76626   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76627   argp2 = (Dali::Actor *)jarg2;
76628   if (!argp2) {
76629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76630     return 0;
76631   }
76632   arg2 = *argp2;
76633   {
76634     try {
76635       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76636     } catch (std::out_of_range& e) {
76637       {
76638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76639       };
76640     } catch (std::exception& e) {
76641       {
76642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76643       };
76644     } catch (Dali::DaliException e) {
76645       {
76646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76647       };
76648     } catch (...) {
76649       {
76650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76651       };
76652     }
76653   }
76654
76655   jresult = result;
76656   return jresult;
76657 }
76658
76659
76660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76662   Dali::Toolkit::Item arg2 ;
76663   float arg3 ;
76664   Dali::Toolkit::Item *argp2 ;
76665
76666   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76667   argp2 = (Dali::Toolkit::Item *)jarg2;
76668   if (!argp2) {
76669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76670     return ;
76671   }
76672   arg2 = *argp2;
76673   arg3 = (float)jarg3;
76674   {
76675     try {
76676       (arg1)->InsertItem(arg2,arg3);
76677     } catch (std::out_of_range& e) {
76678       {
76679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76680       };
76681     } catch (std::exception& e) {
76682       {
76683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76684       };
76685     } catch (Dali::DaliException e) {
76686       {
76687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76688       };
76689     } catch (...) {
76690       {
76691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76692       };
76693     }
76694   }
76695
76696 }
76697
76698
76699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76701   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76702   float arg3 ;
76703
76704   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76705   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76706   if (!arg2) {
76707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76708     return ;
76709   }
76710   arg3 = (float)jarg3;
76711   {
76712     try {
76713       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76714     } catch (std::out_of_range& e) {
76715       {
76716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76717       };
76718     } catch (std::exception& e) {
76719       {
76720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76721       };
76722     } catch (Dali::DaliException e) {
76723       {
76724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76725       };
76726     } catch (...) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76729       };
76730     }
76731   }
76732
76733 }
76734
76735
76736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76737   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76738   Dali::Toolkit::ItemId arg2 ;
76739   float arg3 ;
76740
76741   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76742   arg2 = (Dali::Toolkit::ItemId)jarg2;
76743   arg3 = (float)jarg3;
76744   {
76745     try {
76746       (arg1)->RemoveItem(arg2,arg3);
76747     } catch (std::out_of_range& e) {
76748       {
76749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76750       };
76751     } catch (std::exception& e) {
76752       {
76753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76754       };
76755     } catch (Dali::DaliException e) {
76756       {
76757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76758       };
76759     } catch (...) {
76760       {
76761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76762       };
76763     }
76764   }
76765
76766 }
76767
76768
76769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76770   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76771   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76772   float arg3 ;
76773
76774   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76775   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76776   if (!arg2) {
76777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76778     return ;
76779   }
76780   arg3 = (float)jarg3;
76781   {
76782     try {
76783       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76784     } catch (std::out_of_range& e) {
76785       {
76786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76787       };
76788     } catch (std::exception& e) {
76789       {
76790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76791       };
76792     } catch (Dali::DaliException e) {
76793       {
76794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76795       };
76796     } catch (...) {
76797       {
76798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76799       };
76800     }
76801   }
76802
76803 }
76804
76805
76806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
76807   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76808   Dali::Toolkit::Item arg2 ;
76809   float arg3 ;
76810   Dali::Toolkit::Item *argp2 ;
76811
76812   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76813   argp2 = (Dali::Toolkit::Item *)jarg2;
76814   if (!argp2) {
76815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76816     return ;
76817   }
76818   arg2 = *argp2;
76819   arg3 = (float)jarg3;
76820   {
76821     try {
76822       (arg1)->ReplaceItem(arg2,arg3);
76823     } catch (std::out_of_range& e) {
76824       {
76825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76826       };
76827     } catch (std::exception& e) {
76828       {
76829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76830       };
76831     } catch (Dali::DaliException e) {
76832       {
76833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76834       };
76835     } catch (...) {
76836       {
76837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76838       };
76839     }
76840   }
76841
76842 }
76843
76844
76845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
76846   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76847   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76848   float arg3 ;
76849
76850   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76851   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76852   if (!arg2) {
76853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76854     return ;
76855   }
76856   arg3 = (float)jarg3;
76857   {
76858     try {
76859       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76860     } catch (std::out_of_range& e) {
76861       {
76862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76863       };
76864     } catch (std::exception& e) {
76865       {
76866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76867       };
76868     } catch (Dali::DaliException e) {
76869       {
76870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76871       };
76872     } catch (...) {
76873       {
76874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76875       };
76876     }
76877   }
76878
76879 }
76880
76881
76882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76883   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76884   Dali::Vector3 *arg2 = 0 ;
76885
76886   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76887   arg2 = (Dali::Vector3 *)jarg2;
76888   if (!arg2) {
76889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76890     return ;
76891   }
76892   {
76893     try {
76894       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76895     } catch (std::out_of_range& e) {
76896       {
76897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76898       };
76899     } catch (std::exception& e) {
76900       {
76901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76902       };
76903     } catch (Dali::DaliException e) {
76904       {
76905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76906       };
76907     } catch (...) {
76908       {
76909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76910       };
76911     }
76912   }
76913
76914 }
76915
76916
76917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76918   void * jresult ;
76919   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76920   Dali::Vector3 result;
76921
76922   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76923   {
76924     try {
76925       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76926     } catch (std::out_of_range& e) {
76927       {
76928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76929       };
76930     } catch (std::exception& e) {
76931       {
76932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76933       };
76934     } catch (Dali::DaliException e) {
76935       {
76936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76937       };
76938     } catch (...) {
76939       {
76940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76941       };
76942     }
76943   }
76944
76945   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76946   return jresult;
76947 }
76948
76949
76950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76952   Dali::Vector3 *arg2 = 0 ;
76953
76954   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76955   arg2 = (Dali::Vector3 *)jarg2;
76956   if (!arg2) {
76957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76958     return ;
76959   }
76960   {
76961     try {
76962       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76963     } catch (std::out_of_range& e) {
76964       {
76965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76966       };
76967     } catch (std::exception& e) {
76968       {
76969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76970       };
76971     } catch (Dali::DaliException e) {
76972       {
76973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76974       };
76975     } catch (...) {
76976       {
76977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76978       };
76979     }
76980   }
76981
76982 }
76983
76984
76985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76986   void * jresult ;
76987   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76988   Dali::Vector3 result;
76989
76990   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76991   {
76992     try {
76993       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76994     } catch (std::out_of_range& e) {
76995       {
76996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76997       };
76998     } catch (std::exception& e) {
76999       {
77000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77001       };
77002     } catch (Dali::DaliException e) {
77003       {
77004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77005       };
77006     } catch (...) {
77007       {
77008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77009       };
77010     }
77011   }
77012
77013   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77014   return jresult;
77015 }
77016
77017
77018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77019   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77020   Dali::Toolkit::ItemRange *arg2 = 0 ;
77021
77022   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77023   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77024   if (!arg2) {
77025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77026     return ;
77027   }
77028   {
77029     try {
77030       (arg1)->GetItemsRange(*arg2);
77031     } catch (std::out_of_range& e) {
77032       {
77033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77034       };
77035     } catch (std::exception& e) {
77036       {
77037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77038       };
77039     } catch (Dali::DaliException e) {
77040       {
77041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77042       };
77043     } catch (...) {
77044       {
77045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77046       };
77047     }
77048   }
77049
77050 }
77051
77052
77053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77054   void * jresult ;
77055   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77056   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77057
77058   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77059   {
77060     try {
77061       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77062     } catch (std::out_of_range& e) {
77063       {
77064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77065       };
77066     } catch (std::exception& e) {
77067       {
77068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77069       };
77070     } catch (Dali::DaliException e) {
77071       {
77072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77073       };
77074     } catch (...) {
77075       {
77076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77077       };
77078     }
77079   }
77080
77081   jresult = (void *)result;
77082   return jresult;
77083 }
77084
77085
77086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77087   Dali::Vector3 *arg1 = 0 ;
77088   PropertyInputContainer *arg2 = 0 ;
77089
77090   arg1 = (Dali::Vector3 *)jarg1;
77091   if (!arg1) {
77092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77093     return ;
77094   }
77095   arg2 = (PropertyInputContainer *)jarg2;
77096   if (!arg2) {
77097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77098     return ;
77099   }
77100   {
77101     try {
77102       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77103     } catch (std::out_of_range& e) {
77104       {
77105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77106       };
77107     } catch (std::exception& e) {
77108       {
77109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77110       };
77111     } catch (Dali::DaliException e) {
77112       {
77113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77114       };
77115     } catch (...) {
77116       {
77117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77118       };
77119     }
77120   }
77121
77122 }
77123
77124
77125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77126   Dali::Vector3 *arg1 = 0 ;
77127   PropertyInputContainer *arg2 = 0 ;
77128
77129   arg1 = (Dali::Vector3 *)jarg1;
77130   if (!arg1) {
77131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77132     return ;
77133   }
77134   arg2 = (PropertyInputContainer *)jarg2;
77135   if (!arg2) {
77136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77137     return ;
77138   }
77139   {
77140     try {
77141       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77142     } catch (std::out_of_range& e) {
77143       {
77144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77145       };
77146     } catch (std::exception& e) {
77147       {
77148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77149       };
77150     } catch (Dali::DaliException e) {
77151       {
77152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77153       };
77154     } catch (...) {
77155       {
77156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77157       };
77158     }
77159   }
77160
77161 }
77162
77163
77164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77165   void * jresult ;
77166   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77167
77168   {
77169     try {
77170       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77171     } catch (std::out_of_range& e) {
77172       {
77173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77174       };
77175     } catch (std::exception& e) {
77176       {
77177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77178       };
77179     } catch (Dali::DaliException e) {
77180       {
77181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77182       };
77183     } catch (...) {
77184       {
77185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77186       };
77187     }
77188   }
77189
77190   jresult = (void *)result;
77191   return jresult;
77192 }
77193
77194
77195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77196   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77197
77198   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77199   {
77200     try {
77201       delete arg1;
77202     } catch (std::out_of_range& e) {
77203       {
77204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77205       };
77206     } catch (std::exception& e) {
77207       {
77208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77209       };
77210     } catch (Dali::DaliException e) {
77211       {
77212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77213       };
77214     } catch (...) {
77215       {
77216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77217       };
77218     }
77219   }
77220
77221 }
77222
77223
77224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77225   void * jresult ;
77226   Dali::Path arg1 ;
77227   Dali::Vector3 *arg2 = 0 ;
77228   Dali::Property::Index arg3 ;
77229   Dali::Vector3 *arg4 = 0 ;
77230   unsigned int arg5 ;
77231   Dali::Path *argp1 ;
77232   Dali::Toolkit::ScrollViewPagePathEffect result;
77233
77234   argp1 = (Dali::Path *)jarg1;
77235   if (!argp1) {
77236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77237     return 0;
77238   }
77239   arg1 = *argp1;
77240   arg2 = (Dali::Vector3 *)jarg2;
77241   if (!arg2) {
77242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77243     return 0;
77244   }
77245   arg3 = (Dali::Property::Index)jarg3;
77246   arg4 = (Dali::Vector3 *)jarg4;
77247   if (!arg4) {
77248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77249     return 0;
77250   }
77251   arg5 = (unsigned int)jarg5;
77252   {
77253     try {
77254       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77255     } catch (std::out_of_range& e) {
77256       {
77257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77258       };
77259     } catch (std::exception& e) {
77260       {
77261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77262       };
77263     } catch (Dali::DaliException e) {
77264       {
77265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77266       };
77267     } catch (...) {
77268       {
77269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77270       };
77271     }
77272   }
77273
77274   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77275   return jresult;
77276 }
77277
77278
77279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77280   void * jresult ;
77281   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77282
77283   {
77284     try {
77285       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77286     } catch (std::out_of_range& e) {
77287       {
77288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77289       };
77290     } catch (std::exception& e) {
77291       {
77292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77293       };
77294     } catch (Dali::DaliException e) {
77295       {
77296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77297       };
77298     } catch (...) {
77299       {
77300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77301       };
77302     }
77303   }
77304
77305   jresult = (void *)result;
77306   return jresult;
77307 }
77308
77309
77310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77311   void * jresult ;
77312   Dali::BaseHandle arg1 ;
77313   Dali::BaseHandle *argp1 ;
77314   Dali::Toolkit::ScrollViewPagePathEffect result;
77315
77316   argp1 = (Dali::BaseHandle *)jarg1;
77317   if (!argp1) {
77318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77319     return 0;
77320   }
77321   arg1 = *argp1;
77322   {
77323     try {
77324       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77325     } catch (std::out_of_range& e) {
77326       {
77327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77328       };
77329     } catch (std::exception& e) {
77330       {
77331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77332       };
77333     } catch (Dali::DaliException e) {
77334       {
77335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77336       };
77337     } catch (...) {
77338       {
77339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77340       };
77341     }
77342   }
77343
77344   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77345   return jresult;
77346 }
77347
77348
77349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77350   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77351   Dali::Actor arg2 ;
77352   unsigned int arg3 ;
77353   Dali::Actor *argp2 ;
77354
77355   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77356   argp2 = (Dali::Actor *)jarg2;
77357   if (!argp2) {
77358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77359     return ;
77360   }
77361   arg2 = *argp2;
77362   arg3 = (unsigned int)jarg3;
77363   {
77364     try {
77365       (arg1)->ApplyToPage(arg2,arg3);
77366     } catch (std::out_of_range& e) {
77367       {
77368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77369       };
77370     } catch (std::exception& e) {
77371       {
77372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77373       };
77374     } catch (Dali::DaliException e) {
77375       {
77376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77377       };
77378     } catch (...) {
77379       {
77380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77381       };
77382     }
77383   }
77384
77385 }
77386
77387
77388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77389   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77390
77391   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77392   {
77393     try {
77394       delete arg1;
77395     } catch (std::out_of_range& e) {
77396       {
77397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77398       };
77399     } catch (std::exception& e) {
77400       {
77401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77402       };
77403     } catch (Dali::DaliException e) {
77404       {
77405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77406       };
77407     } catch (...) {
77408       {
77409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77410       };
77411     }
77412   }
77413
77414 }
77415
77416
77417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77418   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77419   Dali::Toolkit::ClampState arg2 ;
77420
77421   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77422   arg2 = (Dali::Toolkit::ClampState)jarg2;
77423   if (arg1) (arg1)->x = arg2;
77424 }
77425
77426
77427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77428   int jresult ;
77429   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77430   Dali::Toolkit::ClampState result;
77431
77432   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77433   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77434   jresult = (int)result;
77435   return jresult;
77436 }
77437
77438
77439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77440   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77441   Dali::Toolkit::ClampState arg2 ;
77442
77443   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77444   arg2 = (Dali::Toolkit::ClampState)jarg2;
77445   if (arg1) (arg1)->y = arg2;
77446 }
77447
77448
77449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77450   int jresult ;
77451   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77452   Dali::Toolkit::ClampState result;
77453
77454   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77455   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77456   jresult = (int)result;
77457   return jresult;
77458 }
77459
77460
77461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77462   void * jresult ;
77463   Dali::Toolkit::ClampState2D *result = 0 ;
77464
77465   {
77466     try {
77467       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77468     } catch (std::out_of_range& e) {
77469       {
77470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77471       };
77472     } catch (std::exception& e) {
77473       {
77474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77475       };
77476     } catch (Dali::DaliException e) {
77477       {
77478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77479       };
77480     } catch (...) {
77481       {
77482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77483       };
77484     }
77485   }
77486
77487   jresult = (void *)result;
77488   return jresult;
77489 }
77490
77491
77492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77493   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77494
77495   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77496   {
77497     try {
77498       delete arg1;
77499     } catch (std::out_of_range& e) {
77500       {
77501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77502       };
77503     } catch (std::exception& e) {
77504       {
77505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77506       };
77507     } catch (Dali::DaliException e) {
77508       {
77509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77510       };
77511     } catch (...) {
77512       {
77513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77514       };
77515     }
77516   }
77517
77518 }
77519
77520
77521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77522   void * jresult ;
77523   float arg1 ;
77524   float arg2 ;
77525   bool arg3 ;
77526   Dali::Toolkit::RulerDomain *result = 0 ;
77527
77528   arg1 = (float)jarg1;
77529   arg2 = (float)jarg2;
77530   arg3 = jarg3 ? true : false;
77531   {
77532     try {
77533       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77534     } catch (std::out_of_range& e) {
77535       {
77536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77537       };
77538     } catch (std::exception& e) {
77539       {
77540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77541       };
77542     } catch (Dali::DaliException e) {
77543       {
77544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77545       };
77546     } catch (...) {
77547       {
77548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77549       };
77550     }
77551   }
77552
77553   jresult = (void *)result;
77554   return jresult;
77555 }
77556
77557
77558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77559   void * jresult ;
77560   float arg1 ;
77561   float arg2 ;
77562   Dali::Toolkit::RulerDomain *result = 0 ;
77563
77564   arg1 = (float)jarg1;
77565   arg2 = (float)jarg2;
77566   {
77567     try {
77568       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77569     } catch (std::out_of_range& e) {
77570       {
77571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77572       };
77573     } catch (std::exception& e) {
77574       {
77575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77576       };
77577     } catch (Dali::DaliException e) {
77578       {
77579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77580       };
77581     } catch (...) {
77582       {
77583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77584       };
77585     }
77586   }
77587
77588   jresult = (void *)result;
77589   return jresult;
77590 }
77591
77592
77593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77594   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77595   float arg2 ;
77596
77597   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77598   arg2 = (float)jarg2;
77599   if (arg1) (arg1)->min = arg2;
77600 }
77601
77602
77603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77604   float jresult ;
77605   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77606   float result;
77607
77608   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77609   result = (float) ((arg1)->min);
77610   jresult = result;
77611   return jresult;
77612 }
77613
77614
77615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77616   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77617   float arg2 ;
77618
77619   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77620   arg2 = (float)jarg2;
77621   if (arg1) (arg1)->max = arg2;
77622 }
77623
77624
77625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77626   float jresult ;
77627   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77628   float result;
77629
77630   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77631   result = (float) ((arg1)->max);
77632   jresult = result;
77633   return jresult;
77634 }
77635
77636
77637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77638   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77639   bool arg2 ;
77640
77641   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77642   arg2 = jarg2 ? true : false;
77643   if (arg1) (arg1)->enabled = arg2;
77644 }
77645
77646
77647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77648   unsigned int jresult ;
77649   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77650   bool result;
77651
77652   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77653   result = (bool) ((arg1)->enabled);
77654   jresult = result;
77655   return jresult;
77656 }
77657
77658
77659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77660   float jresult ;
77661   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77662   float arg2 ;
77663   float arg3 ;
77664   float arg4 ;
77665   float result;
77666
77667   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77668   arg2 = (float)jarg2;
77669   arg3 = (float)jarg3;
77670   arg4 = (float)jarg4;
77671   {
77672     try {
77673       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77674     } catch (std::out_of_range& e) {
77675       {
77676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77677       };
77678     } catch (std::exception& e) {
77679       {
77680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77681       };
77682     } catch (Dali::DaliException e) {
77683       {
77684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77685       };
77686     } catch (...) {
77687       {
77688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77689       };
77690     }
77691   }
77692
77693   jresult = result;
77694   return jresult;
77695 }
77696
77697
77698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77699   float jresult ;
77700   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77701   float arg2 ;
77702   float arg3 ;
77703   float result;
77704
77705   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77706   arg2 = (float)jarg2;
77707   arg3 = (float)jarg3;
77708   {
77709     try {
77710       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77711     } catch (std::out_of_range& e) {
77712       {
77713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77714       };
77715     } catch (std::exception& e) {
77716       {
77717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77718       };
77719     } catch (Dali::DaliException e) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77722       };
77723     } catch (...) {
77724       {
77725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77726       };
77727     }
77728   }
77729
77730   jresult = result;
77731   return jresult;
77732 }
77733
77734
77735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77736   float jresult ;
77737   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77738   float arg2 ;
77739   float result;
77740
77741   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77742   arg2 = (float)jarg2;
77743   {
77744     try {
77745       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77746     } catch (std::out_of_range& e) {
77747       {
77748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77749       };
77750     } catch (std::exception& e) {
77751       {
77752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77753       };
77754     } catch (Dali::DaliException e) {
77755       {
77756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77757       };
77758     } catch (...) {
77759       {
77760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77761       };
77762     }
77763   }
77764
77765   jresult = result;
77766   return jresult;
77767 }
77768
77769
77770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77771   float jresult ;
77772   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77773   float arg2 ;
77774   float arg3 ;
77775   float arg4 ;
77776   Dali::Toolkit::ClampState *arg5 = 0 ;
77777   float result;
77778
77779   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77780   arg2 = (float)jarg2;
77781   arg3 = (float)jarg3;
77782   arg4 = (float)jarg4;
77783   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77784   if (!arg5) {
77785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77786     return 0;
77787   }
77788   {
77789     try {
77790       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77791     } catch (std::out_of_range& e) {
77792       {
77793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77794       };
77795     } catch (std::exception& e) {
77796       {
77797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77798       };
77799     } catch (Dali::DaliException e) {
77800       {
77801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77802       };
77803     } catch (...) {
77804       {
77805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77806       };
77807     }
77808   }
77809
77810   jresult = result;
77811   return jresult;
77812 }
77813
77814
77815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
77816   float jresult ;
77817   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77818   float result;
77819
77820   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77821   {
77822     try {
77823       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
77824     } catch (std::out_of_range& e) {
77825       {
77826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77827       };
77828     } catch (std::exception& e) {
77829       {
77830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77831       };
77832     } catch (Dali::DaliException e) {
77833       {
77834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77835       };
77836     } catch (...) {
77837       {
77838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77839       };
77840     }
77841   }
77842
77843   jresult = result;
77844   return jresult;
77845 }
77846
77847
77848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77849   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77850
77851   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77852   {
77853     try {
77854       delete arg1;
77855     } catch (std::out_of_range& e) {
77856       {
77857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77858       };
77859     } catch (std::exception& e) {
77860       {
77861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77862       };
77863     } catch (Dali::DaliException e) {
77864       {
77865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77866       };
77867     } catch (...) {
77868       {
77869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77870       };
77871     }
77872   }
77873
77874 }
77875
77876
77877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77878   float jresult ;
77879   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77880   float arg2 ;
77881   float arg3 ;
77882   float result;
77883
77884   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77885   arg2 = (float)jarg2;
77886   arg3 = (float)jarg3;
77887   {
77888     try {
77889       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77890     } catch (std::out_of_range& e) {
77891       {
77892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77893       };
77894     } catch (std::exception& e) {
77895       {
77896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77897       };
77898     } catch (Dali::DaliException e) {
77899       {
77900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77901       };
77902     } catch (...) {
77903       {
77904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77905       };
77906     }
77907   }
77908
77909   jresult = result;
77910   return jresult;
77911 }
77912
77913
77914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77915   float jresult ;
77916   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77917   float arg2 ;
77918   float result;
77919
77920   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77921   arg2 = (float)jarg2;
77922   {
77923     try {
77924       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77925     } catch (std::out_of_range& e) {
77926       {
77927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77928       };
77929     } catch (std::exception& e) {
77930       {
77931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77932       };
77933     } catch (Dali::DaliException e) {
77934       {
77935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77936       };
77937     } catch (...) {
77938       {
77939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77940       };
77941     }
77942   }
77943
77944   jresult = result;
77945   return jresult;
77946 }
77947
77948
77949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77950   float jresult ;
77951   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77952   unsigned int arg2 ;
77953   unsigned int *arg3 = 0 ;
77954   bool arg4 ;
77955   float result;
77956
77957   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77958   arg2 = (unsigned int)jarg2;
77959   arg3 = (unsigned int *)jarg3;
77960   arg4 = jarg4 ? true : false;
77961   {
77962     try {
77963       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77964     } catch (std::out_of_range& e) {
77965       {
77966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77967       };
77968     } catch (std::exception& e) {
77969       {
77970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77971       };
77972     } catch (Dali::DaliException e) {
77973       {
77974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77975       };
77976     } catch (...) {
77977       {
77978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77979       };
77980     }
77981   }
77982
77983   jresult = result;
77984   return jresult;
77985 }
77986
77987
77988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77989   unsigned int jresult ;
77990   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77991   float arg2 ;
77992   bool arg3 ;
77993   unsigned int result;
77994
77995   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77996   arg2 = (float)jarg2;
77997   arg3 = jarg3 ? true : false;
77998   {
77999     try {
78000       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78001     } catch (std::out_of_range& e) {
78002       {
78003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78004       };
78005     } catch (std::exception& e) {
78006       {
78007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78008       };
78009     } catch (Dali::DaliException e) {
78010       {
78011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78012       };
78013     } catch (...) {
78014       {
78015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78016       };
78017     }
78018   }
78019
78020   jresult = result;
78021   return jresult;
78022 }
78023
78024
78025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78026   unsigned int jresult ;
78027   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78028   unsigned int result;
78029
78030   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78031   {
78032     try {
78033       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78034     } catch (std::out_of_range& e) {
78035       {
78036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78037       };
78038     } catch (std::exception& e) {
78039       {
78040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78041       };
78042     } catch (Dali::DaliException e) {
78043       {
78044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78045       };
78046     } catch (...) {
78047       {
78048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78049       };
78050     }
78051   }
78052
78053   jresult = result;
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78059   int jresult ;
78060   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78061   Dali::Toolkit::Ruler::RulerType result;
78062
78063   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78064   {
78065     try {
78066       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78067     } catch (std::out_of_range& e) {
78068       {
78069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78070       };
78071     } catch (std::exception& e) {
78072       {
78073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78074       };
78075     } catch (Dali::DaliException e) {
78076       {
78077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78078       };
78079     } catch (...) {
78080       {
78081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78082       };
78083     }
78084   }
78085
78086   jresult = (int)result;
78087   return jresult;
78088 }
78089
78090
78091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78092   unsigned int jresult ;
78093   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78094   bool result;
78095
78096   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78097   {
78098     try {
78099       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78100     } catch (std::out_of_range& e) {
78101       {
78102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78103       };
78104     } catch (std::exception& e) {
78105       {
78106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78107       };
78108     } catch (Dali::DaliException e) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78111       };
78112     } catch (...) {
78113       {
78114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78115       };
78116     }
78117   }
78118
78119   jresult = result;
78120   return jresult;
78121 }
78122
78123
78124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78125   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78126
78127   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78128   {
78129     try {
78130       (arg1)->Enable();
78131     } catch (std::out_of_range& e) {
78132       {
78133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78134       };
78135     } catch (std::exception& e) {
78136       {
78137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78138       };
78139     } catch (Dali::DaliException e) {
78140       {
78141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78142       };
78143     } catch (...) {
78144       {
78145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78146       };
78147     }
78148   }
78149
78150 }
78151
78152
78153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78154   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78155
78156   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78157   {
78158     try {
78159       (arg1)->Disable();
78160     } catch (std::out_of_range& e) {
78161       {
78162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78163       };
78164     } catch (std::exception& e) {
78165       {
78166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78167       };
78168     } catch (Dali::DaliException e) {
78169       {
78170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78171       };
78172     } catch (...) {
78173       {
78174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78175       };
78176     }
78177   }
78178
78179 }
78180
78181
78182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78183   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78184   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78185   Dali::Toolkit::RulerDomain *argp2 ;
78186
78187   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78188   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78189   if (!argp2) {
78190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78191     return ;
78192   }
78193   arg2 = *argp2;
78194   {
78195     try {
78196       (arg1)->SetDomain(arg2);
78197     } catch (std::out_of_range& e) {
78198       {
78199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78200       };
78201     } catch (std::exception& e) {
78202       {
78203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78204       };
78205     } catch (Dali::DaliException e) {
78206       {
78207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78208       };
78209     } catch (...) {
78210       {
78211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78212       };
78213     }
78214   }
78215
78216 }
78217
78218
78219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78220   void * jresult ;
78221   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78222   Dali::Toolkit::RulerDomain *result = 0 ;
78223
78224   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78225   {
78226     try {
78227       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78228     } catch (std::out_of_range& e) {
78229       {
78230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78231       };
78232     } catch (std::exception& e) {
78233       {
78234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78235       };
78236     } catch (Dali::DaliException e) {
78237       {
78238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78239       };
78240     } catch (...) {
78241       {
78242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78243       };
78244     }
78245   }
78246
78247   jresult = (void *)result;
78248   return jresult;
78249 }
78250
78251
78252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78253   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78254
78255   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78256   {
78257     try {
78258       (arg1)->DisableDomain();
78259     } catch (std::out_of_range& e) {
78260       {
78261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78262       };
78263     } catch (std::exception& e) {
78264       {
78265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78266       };
78267     } catch (Dali::DaliException e) {
78268       {
78269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78270       };
78271     } catch (...) {
78272       {
78273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78274       };
78275     }
78276   }
78277
78278 }
78279
78280
78281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78282   float jresult ;
78283   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78284   float arg2 ;
78285   float arg3 ;
78286   float arg4 ;
78287   float result;
78288
78289   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78290   arg2 = (float)jarg2;
78291   arg3 = (float)jarg3;
78292   arg4 = (float)jarg4;
78293   {
78294     try {
78295       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78296     } catch (std::out_of_range& e) {
78297       {
78298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78299       };
78300     } catch (std::exception& e) {
78301       {
78302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78303       };
78304     } catch (Dali::DaliException e) {
78305       {
78306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78307       };
78308     } catch (...) {
78309       {
78310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78311       };
78312     }
78313   }
78314
78315   jresult = result;
78316   return jresult;
78317 }
78318
78319
78320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78321   float jresult ;
78322   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78323   float arg2 ;
78324   float arg3 ;
78325   float result;
78326
78327   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78328   arg2 = (float)jarg2;
78329   arg3 = (float)jarg3;
78330   {
78331     try {
78332       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78333     } catch (std::out_of_range& e) {
78334       {
78335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78336       };
78337     } catch (std::exception& e) {
78338       {
78339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78340       };
78341     } catch (Dali::DaliException e) {
78342       {
78343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78344       };
78345     } catch (...) {
78346       {
78347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78348       };
78349     }
78350   }
78351
78352   jresult = result;
78353   return jresult;
78354 }
78355
78356
78357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78358   float jresult ;
78359   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78360   float arg2 ;
78361   float result;
78362
78363   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78364   arg2 = (float)jarg2;
78365   {
78366     try {
78367       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78368     } catch (std::out_of_range& e) {
78369       {
78370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78371       };
78372     } catch (std::exception& e) {
78373       {
78374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78375       };
78376     } catch (Dali::DaliException e) {
78377       {
78378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78379       };
78380     } catch (...) {
78381       {
78382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78383       };
78384     }
78385   }
78386
78387   jresult = result;
78388   return jresult;
78389 }
78390
78391
78392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78393   float jresult ;
78394   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78395   float arg2 ;
78396   float arg3 ;
78397   float arg4 ;
78398   Dali::Toolkit::ClampState *arg5 = 0 ;
78399   float result;
78400
78401   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78402   arg2 = (float)jarg2;
78403   arg3 = (float)jarg3;
78404   arg4 = (float)jarg4;
78405   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78406   if (!arg5) {
78407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78408     return 0;
78409   }
78410   {
78411     try {
78412       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78413     } catch (std::out_of_range& e) {
78414       {
78415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78416       };
78417     } catch (std::exception& e) {
78418       {
78419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78420       };
78421     } catch (Dali::DaliException e) {
78422       {
78423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78424       };
78425     } catch (...) {
78426       {
78427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78428       };
78429     }
78430   }
78431
78432   jresult = result;
78433   return jresult;
78434 }
78435
78436
78437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78438   float jresult ;
78439   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78440   float arg2 ;
78441   float arg3 ;
78442   float arg4 ;
78443   float arg5 ;
78444   float result;
78445
78446   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78447   arg2 = (float)jarg2;
78448   arg3 = (float)jarg3;
78449   arg4 = (float)jarg4;
78450   arg5 = (float)jarg5;
78451   {
78452     try {
78453       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78454     } catch (std::out_of_range& e) {
78455       {
78456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78457       };
78458     } catch (std::exception& e) {
78459       {
78460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78461       };
78462     } catch (Dali::DaliException e) {
78463       {
78464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78465       };
78466     } catch (...) {
78467       {
78468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78469       };
78470     }
78471   }
78472
78473   jresult = result;
78474   return jresult;
78475 }
78476
78477
78478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78479   float jresult ;
78480   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78481   float arg2 ;
78482   float arg3 ;
78483   float arg4 ;
78484   float result;
78485
78486   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78487   arg2 = (float)jarg2;
78488   arg3 = (float)jarg3;
78489   arg4 = (float)jarg4;
78490   {
78491     try {
78492       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78493     } catch (std::out_of_range& e) {
78494       {
78495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78496       };
78497     } catch (std::exception& e) {
78498       {
78499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78500       };
78501     } catch (Dali::DaliException e) {
78502       {
78503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78504       };
78505     } catch (...) {
78506       {
78507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78508       };
78509     }
78510   }
78511
78512   jresult = result;
78513   return jresult;
78514 }
78515
78516
78517 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78518   float jresult ;
78519   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78520   float arg2 ;
78521   float arg3 ;
78522   float result;
78523
78524   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78525   arg2 = (float)jarg2;
78526   arg3 = (float)jarg3;
78527   {
78528     try {
78529       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78530     } catch (std::out_of_range& e) {
78531       {
78532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78533       };
78534     } catch (std::exception& e) {
78535       {
78536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78537       };
78538     } catch (Dali::DaliException e) {
78539       {
78540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78541       };
78542     } catch (...) {
78543       {
78544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78545       };
78546     }
78547   }
78548
78549   jresult = result;
78550   return jresult;
78551 }
78552
78553
78554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78555   float jresult ;
78556   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78557   float arg2 ;
78558   float result;
78559
78560   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78561   arg2 = (float)jarg2;
78562   {
78563     try {
78564       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
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 float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78590   float jresult ;
78591   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78592   float arg2 ;
78593   float arg3 ;
78594   float arg4 ;
78595   float arg5 ;
78596   Dali::Toolkit::ClampState *arg6 = 0 ;
78597   float result;
78598
78599   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78600   arg2 = (float)jarg2;
78601   arg3 = (float)jarg3;
78602   arg4 = (float)jarg4;
78603   arg5 = (float)jarg5;
78604   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78605   if (!arg6) {
78606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78607     return 0;
78608   }
78609   {
78610     try {
78611       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78612     } catch (std::out_of_range& e) {
78613       {
78614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78615       };
78616     } catch (std::exception& e) {
78617       {
78618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78619       };
78620     } catch (Dali::DaliException e) {
78621       {
78622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78623       };
78624     } catch (...) {
78625       {
78626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78627       };
78628     }
78629   }
78630
78631   jresult = result;
78632   return jresult;
78633 }
78634
78635
78636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78637   void * jresult ;
78638   Dali::Toolkit::DefaultRuler *result = 0 ;
78639
78640   {
78641     try {
78642       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78643     } catch (std::out_of_range& e) {
78644       {
78645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78646       };
78647     } catch (std::exception& e) {
78648       {
78649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78650       };
78651     } catch (Dali::DaliException e) {
78652       {
78653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78654       };
78655     } catch (...) {
78656       {
78657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78658       };
78659     }
78660   }
78661
78662   jresult = (void *)result;
78663   return jresult;
78664 }
78665
78666
78667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78668   float jresult ;
78669   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78670   float arg2 ;
78671   float arg3 ;
78672   float result;
78673
78674   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78675   arg2 = (float)jarg2;
78676   arg3 = (float)jarg3;
78677   {
78678     try {
78679       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78680     } catch (std::out_of_range& e) {
78681       {
78682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78683       };
78684     } catch (std::exception& e) {
78685       {
78686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78687       };
78688     } catch (Dali::DaliException e) {
78689       {
78690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78691       };
78692     } catch (...) {
78693       {
78694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78695       };
78696     }
78697   }
78698
78699   jresult = result;
78700   return jresult;
78701 }
78702
78703
78704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78705   float jresult ;
78706   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78707   unsigned int arg2 ;
78708   unsigned int *arg3 = 0 ;
78709   bool arg4 ;
78710   float result;
78711
78712   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78713   arg2 = (unsigned int)jarg2;
78714   arg3 = (unsigned int *)jarg3;
78715   arg4 = jarg4 ? true : false;
78716   {
78717     try {
78718       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78719     } catch (std::out_of_range& e) {
78720       {
78721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78722       };
78723     } catch (std::exception& e) {
78724       {
78725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78726       };
78727     } catch (Dali::DaliException e) {
78728       {
78729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78730       };
78731     } catch (...) {
78732       {
78733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78734       };
78735     }
78736   }
78737
78738   jresult = result;
78739   return jresult;
78740 }
78741
78742
78743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78744   unsigned int jresult ;
78745   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78746   float arg2 ;
78747   bool arg3 ;
78748   unsigned int result;
78749
78750   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78751   arg2 = (float)jarg2;
78752   arg3 = jarg3 ? true : false;
78753   {
78754     try {
78755       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78756     } catch (std::out_of_range& e) {
78757       {
78758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78759       };
78760     } catch (std::exception& e) {
78761       {
78762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78763       };
78764     } catch (Dali::DaliException e) {
78765       {
78766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78767       };
78768     } catch (...) {
78769       {
78770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78771       };
78772     }
78773   }
78774
78775   jresult = result;
78776   return jresult;
78777 }
78778
78779
78780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78781   unsigned int jresult ;
78782   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78783   unsigned int result;
78784
78785   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78786   {
78787     try {
78788       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78789     } catch (std::out_of_range& e) {
78790       {
78791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78792       };
78793     } catch (std::exception& e) {
78794       {
78795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78796       };
78797     } catch (Dali::DaliException e) {
78798       {
78799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78800       };
78801     } catch (...) {
78802       {
78803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78804       };
78805     }
78806   }
78807
78808   jresult = result;
78809   return jresult;
78810 }
78811
78812
78813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
78814   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78815
78816   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78817   {
78818     try {
78819       delete arg1;
78820     } catch (std::out_of_range& e) {
78821       {
78822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78823       };
78824     } catch (std::exception& e) {
78825       {
78826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78827       };
78828     } catch (Dali::DaliException e) {
78829       {
78830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78831       };
78832     } catch (...) {
78833       {
78834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78835       };
78836     }
78837   }
78838
78839 }
78840
78841
78842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
78843   void * jresult ;
78844   float arg1 ;
78845   Dali::Toolkit::FixedRuler *result = 0 ;
78846
78847   arg1 = (float)jarg1;
78848   {
78849     try {
78850       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78851     } catch (std::out_of_range& e) {
78852       {
78853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78854       };
78855     } catch (std::exception& e) {
78856       {
78857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78858       };
78859     } catch (Dali::DaliException e) {
78860       {
78861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78862       };
78863     } catch (...) {
78864       {
78865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78866       };
78867     }
78868   }
78869
78870   jresult = (void *)result;
78871   return jresult;
78872 }
78873
78874
78875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78876   void * jresult ;
78877   Dali::Toolkit::FixedRuler *result = 0 ;
78878
78879   {
78880     try {
78881       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78882     } catch (std::out_of_range& e) {
78883       {
78884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78885       };
78886     } catch (std::exception& e) {
78887       {
78888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78889       };
78890     } catch (Dali::DaliException e) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78893       };
78894     } catch (...) {
78895       {
78896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78897       };
78898     }
78899   }
78900
78901   jresult = (void *)result;
78902   return jresult;
78903 }
78904
78905
78906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78907   float jresult ;
78908   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78909   float arg2 ;
78910   float arg3 ;
78911   float result;
78912
78913   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78914   arg2 = (float)jarg2;
78915   arg3 = (float)jarg3;
78916   {
78917     try {
78918       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78919     } catch (std::out_of_range& e) {
78920       {
78921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78922       };
78923     } catch (std::exception& e) {
78924       {
78925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78926       };
78927     } catch (Dali::DaliException e) {
78928       {
78929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78930       };
78931     } catch (...) {
78932       {
78933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78934       };
78935     }
78936   }
78937
78938   jresult = result;
78939   return jresult;
78940 }
78941
78942
78943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78944   float jresult ;
78945   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78946   unsigned int arg2 ;
78947   unsigned int *arg3 = 0 ;
78948   bool arg4 ;
78949   float result;
78950
78951   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78952   arg2 = (unsigned int)jarg2;
78953   arg3 = (unsigned int *)jarg3;
78954   arg4 = jarg4 ? true : false;
78955   {
78956     try {
78957       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78958     } catch (std::out_of_range& e) {
78959       {
78960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78961       };
78962     } catch (std::exception& e) {
78963       {
78964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78965       };
78966     } catch (Dali::DaliException e) {
78967       {
78968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78969       };
78970     } catch (...) {
78971       {
78972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78973       };
78974     }
78975   }
78976
78977   jresult = result;
78978   return jresult;
78979 }
78980
78981
78982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78983   unsigned int jresult ;
78984   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78985   float arg2 ;
78986   bool arg3 ;
78987   unsigned int result;
78988
78989   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78990   arg2 = (float)jarg2;
78991   arg3 = jarg3 ? true : false;
78992   {
78993     try {
78994       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78995     } catch (std::out_of_range& e) {
78996       {
78997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78998       };
78999     } catch (std::exception& e) {
79000       {
79001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79002       };
79003     } catch (Dali::DaliException e) {
79004       {
79005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79006       };
79007     } catch (...) {
79008       {
79009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79010       };
79011     }
79012   }
79013
79014   jresult = result;
79015   return jresult;
79016 }
79017
79018
79019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79020   unsigned int jresult ;
79021   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79022   unsigned int result;
79023
79024   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79025   {
79026     try {
79027       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79028     } catch (std::out_of_range& e) {
79029       {
79030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79031       };
79032     } catch (std::exception& e) {
79033       {
79034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79035       };
79036     } catch (Dali::DaliException e) {
79037       {
79038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79039       };
79040     } catch (...) {
79041       {
79042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79043       };
79044     }
79045   }
79046
79047   jresult = result;
79048   return jresult;
79049 }
79050
79051
79052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79053   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79054
79055   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79056   {
79057     try {
79058       delete arg1;
79059     } catch (std::out_of_range& e) {
79060       {
79061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79062       };
79063     } catch (std::exception& e) {
79064       {
79065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79066       };
79067     } catch (Dali::DaliException e) {
79068       {
79069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79070       };
79071     } catch (...) {
79072       {
79073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79074       };
79075     }
79076   }
79077
79078 }
79079
79080
79081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79082   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79083   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79084
79085   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79086   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79087   if (arg1) (arg1)->scale = *arg2;
79088 }
79089
79090
79091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79092   void * jresult ;
79093   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79094   Dali::Toolkit::ClampState2D *result = 0 ;
79095
79096   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79097   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79098   jresult = (void *)result;
79099   return jresult;
79100 }
79101
79102
79103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79104   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79105   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79106
79107   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79108   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79109   if (arg1) (arg1)->position = *arg2;
79110 }
79111
79112
79113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79114   void * jresult ;
79115   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79116   Dali::Toolkit::ClampState2D *result = 0 ;
79117
79118   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79119   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79120   jresult = (void *)result;
79121   return jresult;
79122 }
79123
79124
79125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79126   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79127   Dali::Toolkit::ClampState arg2 ;
79128
79129   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79130   arg2 = (Dali::Toolkit::ClampState)jarg2;
79131   if (arg1) (arg1)->rotation = arg2;
79132 }
79133
79134
79135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79136   int jresult ;
79137   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79138   Dali::Toolkit::ClampState result;
79139
79140   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79141   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79142   jresult = (int)result;
79143   return jresult;
79144 }
79145
79146
79147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79148   void * jresult ;
79149   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79150
79151   {
79152     try {
79153       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79154     } catch (std::out_of_range& e) {
79155       {
79156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79157       };
79158     } catch (std::exception& e) {
79159       {
79160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79161       };
79162     } catch (Dali::DaliException e) {
79163       {
79164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79165       };
79166     } catch (...) {
79167       {
79168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79169       };
79170     }
79171   }
79172
79173   jresult = (void *)result;
79174   return jresult;
79175 }
79176
79177
79178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79179   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79180
79181   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79182   {
79183     try {
79184       delete arg1;
79185     } catch (std::out_of_range& e) {
79186       {
79187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79188       };
79189     } catch (std::exception& e) {
79190       {
79191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79192       };
79193     } catch (Dali::DaliException e) {
79194       {
79195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79196       };
79197     } catch (...) {
79198       {
79199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79200       };
79201     }
79202   }
79203
79204 }
79205
79206
79207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79208   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79209   Dali::Toolkit::SnapType arg2 ;
79210
79211   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79212   arg2 = (Dali::Toolkit::SnapType)jarg2;
79213   if (arg1) (arg1)->type = arg2;
79214 }
79215
79216
79217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79218   int jresult ;
79219   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79220   Dali::Toolkit::SnapType result;
79221
79222   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79223   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79224   jresult = (int)result;
79225   return jresult;
79226 }
79227
79228
79229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79230   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79231   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79232
79233   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79234   arg2 = (Dali::Vector2 *)jarg2;
79235   if (arg1) (arg1)->position = *arg2;
79236 }
79237
79238
79239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79240   void * jresult ;
79241   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79242   Dali::Vector2 *result = 0 ;
79243
79244   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79245   result = (Dali::Vector2 *)& ((arg1)->position);
79246   jresult = (void *)result;
79247   return jresult;
79248 }
79249
79250
79251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79252   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79253   float arg2 ;
79254
79255   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79256   arg2 = (float)jarg2;
79257   if (arg1) (arg1)->duration = arg2;
79258 }
79259
79260
79261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79262   float jresult ;
79263   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79264   float result;
79265
79266   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79267   result = (float) ((arg1)->duration);
79268   jresult = result;
79269   return jresult;
79270 }
79271
79272
79273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79274   void * jresult ;
79275   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79276
79277   {
79278     try {
79279       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79280     } catch (std::out_of_range& e) {
79281       {
79282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79283       };
79284     } catch (std::exception& e) {
79285       {
79286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79287       };
79288     } catch (Dali::DaliException e) {
79289       {
79290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79291       };
79292     } catch (...) {
79293       {
79294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79295       };
79296     }
79297   }
79298
79299   jresult = (void *)result;
79300   return jresult;
79301 }
79302
79303
79304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79305   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79306
79307   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79308   {
79309     try {
79310       delete arg1;
79311     } catch (std::out_of_range& e) {
79312       {
79313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79314       };
79315     } catch (std::exception& e) {
79316       {
79317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79318       };
79319     } catch (Dali::DaliException e) {
79320       {
79321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79322       };
79323     } catch (...) {
79324       {
79325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79326       };
79327     }
79328   }
79329
79330 }
79331
79332
79333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79334   int jresult ;
79335   int result;
79336
79337   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79338   jresult = (int)result;
79339   return jresult;
79340 }
79341
79342
79343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79344   int jresult ;
79345   int result;
79346
79347   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79348   jresult = (int)result;
79349   return jresult;
79350 }
79351
79352
79353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79354   int jresult ;
79355   int result;
79356
79357   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79358   jresult = (int)result;
79359   return jresult;
79360 }
79361
79362
79363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79364   int jresult ;
79365   int result;
79366
79367   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79368   jresult = (int)result;
79369   return jresult;
79370 }
79371
79372
79373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79374   int jresult ;
79375   int result;
79376
79377   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79378   jresult = (int)result;
79379   return jresult;
79380 }
79381
79382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79383   int jresult ;
79384   int result;
79385
79386   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79387   jresult = (int)result;
79388   return jresult;
79389 }
79390
79391
79392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79393   int jresult ;
79394   int result;
79395
79396   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79397   jresult = (int)result;
79398   return jresult;
79399 }
79400
79401
79402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79403   int jresult ;
79404   int result;
79405
79406   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79407   jresult = (int)result;
79408   return jresult;
79409 }
79410
79411
79412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79413   int jresult ;
79414   int result;
79415
79416   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79417   jresult = (int)result;
79418   return jresult;
79419 }
79420
79421
79422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79423   int jresult ;
79424   int result;
79425
79426   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79427   jresult = (int)result;
79428   return jresult;
79429 }
79430
79431
79432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79433   int jresult ;
79434   int result;
79435
79436   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79437   jresult = (int)result;
79438   return jresult;
79439 }
79440
79441
79442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79443   int jresult ;
79444   int result;
79445
79446   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79447   jresult = (int)result;
79448   return jresult;
79449 }
79450
79451
79452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79453   int jresult ;
79454   int result;
79455
79456   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79457   jresult = (int)result;
79458   return jresult;
79459 }
79460
79461
79462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79463   int jresult ;
79464   int result;
79465
79466   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79467   jresult = (int)result;
79468   return jresult;
79469 }
79470
79471
79472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79473   int jresult ;
79474   int result;
79475
79476   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79477   jresult = (int)result;
79478   return jresult;
79479 }
79480
79481
79482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79483   int jresult ;
79484   int result;
79485
79486   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79487   jresult = (int)result;
79488   return jresult;
79489 }
79490
79491
79492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79493   int jresult ;
79494   int result;
79495
79496   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79497   jresult = (int)result;
79498   return jresult;
79499 }
79500
79501
79502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79503   int jresult ;
79504   int result;
79505
79506   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79507   jresult = (int)result;
79508   return jresult;
79509 }
79510
79511
79512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79513   int jresult ;
79514   int result;
79515
79516   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79517   jresult = (int)result;
79518   return jresult;
79519 }
79520
79521
79522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79523   int jresult ;
79524   int result;
79525
79526   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79527   jresult = (int)result;
79528   return jresult;
79529 }
79530
79531
79532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79533   int jresult ;
79534   int result;
79535
79536   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79537   jresult = (int)result;
79538   return jresult;
79539 }
79540
79541
79542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79543   int jresult ;
79544   int result;
79545
79546   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79547   jresult = (int)result;
79548   return jresult;
79549 }
79550
79551
79552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79553   int jresult ;
79554   int result;
79555
79556   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79557   jresult = (int)result;
79558   return jresult;
79559 }
79560
79561
79562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79563   int jresult ;
79564   int result;
79565
79566   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79567   jresult = (int)result;
79568   return jresult;
79569 }
79570
79571
79572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79573   int jresult ;
79574   int result;
79575
79576   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79577   jresult = (int)result;
79578   return jresult;
79579 }
79580
79581
79582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79583   int jresult ;
79584   int result;
79585
79586   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79587   jresult = (int)result;
79588   return jresult;
79589 }
79590
79591
79592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79593   void * jresult ;
79594   Dali::Toolkit::ScrollView::Property *result = 0 ;
79595
79596   {
79597     try {
79598       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79599     } catch (std::out_of_range& e) {
79600       {
79601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79602       };
79603     } catch (std::exception& e) {
79604       {
79605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79606       };
79607     } catch (Dali::DaliException e) {
79608       {
79609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79610       };
79611     } catch (...) {
79612       {
79613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79614       };
79615     }
79616   }
79617
79618   jresult = (void *)result;
79619   return jresult;
79620 }
79621
79622
79623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79624   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79625
79626   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79627   {
79628     try {
79629       delete arg1;
79630     } catch (std::out_of_range& e) {
79631       {
79632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79633       };
79634     } catch (std::exception& e) {
79635       {
79636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79637       };
79638     } catch (Dali::DaliException e) {
79639       {
79640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79641       };
79642     } catch (...) {
79643       {
79644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79645       };
79646     }
79647   }
79648
79649 }
79650
79651
79652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79653   void * jresult ;
79654   Dali::Toolkit::ScrollView *result = 0 ;
79655
79656   {
79657     try {
79658       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79659     } catch (std::out_of_range& e) {
79660       {
79661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79662       };
79663     } catch (std::exception& e) {
79664       {
79665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79666       };
79667     } catch (Dali::DaliException e) {
79668       {
79669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79670       };
79671     } catch (...) {
79672       {
79673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79674       };
79675     }
79676   }
79677
79678   jresult = (void *)result;
79679   return jresult;
79680 }
79681
79682
79683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79684   void * jresult ;
79685   Dali::Toolkit::ScrollView *arg1 = 0 ;
79686   Dali::Toolkit::ScrollView *result = 0 ;
79687
79688   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79689   if (!arg1) {
79690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79691     return 0;
79692   }
79693   {
79694     try {
79695       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79696     } catch (std::out_of_range& e) {
79697       {
79698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79699       };
79700     } catch (std::exception& e) {
79701       {
79702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79703       };
79704     } catch (Dali::DaliException e) {
79705       {
79706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79707       };
79708     } catch (...) {
79709       {
79710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79711       };
79712     }
79713   }
79714
79715   jresult = (void *)result;
79716   return jresult;
79717 }
79718
79719
79720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79721   void * jresult ;
79722   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79723   Dali::Toolkit::ScrollView *arg2 = 0 ;
79724   Dali::Toolkit::ScrollView *result = 0 ;
79725
79726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79727   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79728   if (!arg2) {
79729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79730     return 0;
79731   }
79732   {
79733     try {
79734       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79735     } catch (std::out_of_range& e) {
79736       {
79737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79738       };
79739     } catch (std::exception& e) {
79740       {
79741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79742       };
79743     } catch (Dali::DaliException e) {
79744       {
79745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79746       };
79747     } catch (...) {
79748       {
79749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79750       };
79751     }
79752   }
79753
79754   jresult = (void *)result;
79755   return jresult;
79756 }
79757
79758
79759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79760   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79761
79762   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79763   {
79764     try {
79765       delete arg1;
79766     } catch (std::out_of_range& e) {
79767       {
79768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79769       };
79770     } catch (std::exception& e) {
79771       {
79772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79773       };
79774     } catch (Dali::DaliException e) {
79775       {
79776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79777       };
79778     } catch (...) {
79779       {
79780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79781       };
79782     }
79783   }
79784
79785 }
79786
79787
79788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79789   void * jresult ;
79790   Dali::Toolkit::ScrollView result;
79791
79792   {
79793     try {
79794       result = Dali::Toolkit::ScrollView::New();
79795     } catch (std::out_of_range& e) {
79796       {
79797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79798       };
79799     } catch (std::exception& e) {
79800       {
79801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79802       };
79803     } catch (Dali::DaliException e) {
79804       {
79805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79806       };
79807     } catch (...) {
79808       {
79809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79810       };
79811     }
79812   }
79813
79814   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79815   return jresult;
79816 }
79817
79818
79819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
79820   void * jresult ;
79821   Dali::BaseHandle arg1 ;
79822   Dali::BaseHandle *argp1 ;
79823   Dali::Toolkit::ScrollView result;
79824
79825   argp1 = (Dali::BaseHandle *)jarg1;
79826   if (!argp1) {
79827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79828     return 0;
79829   }
79830   arg1 = *argp1;
79831   {
79832     try {
79833       result = Dali::Toolkit::ScrollView::DownCast(arg1);
79834     } catch (std::out_of_range& e) {
79835       {
79836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79837       };
79838     } catch (std::exception& e) {
79839       {
79840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79841       };
79842     } catch (Dali::DaliException e) {
79843       {
79844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79845       };
79846     } catch (...) {
79847       {
79848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79849       };
79850     }
79851   }
79852
79853   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79854   return jresult;
79855 }
79856
79857
79858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79859   void * jresult ;
79860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79861   Dali::AlphaFunction result;
79862
79863   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79864   {
79865     try {
79866       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79867     } catch (std::out_of_range& e) {
79868       {
79869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79870       };
79871     } catch (std::exception& e) {
79872       {
79873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79874       };
79875     } catch (Dali::DaliException e) {
79876       {
79877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79878       };
79879     } catch (...) {
79880       {
79881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79882       };
79883     }
79884   }
79885
79886   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79887   return jresult;
79888 }
79889
79890
79891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79892   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79893   Dali::AlphaFunction arg2 ;
79894   Dali::AlphaFunction *argp2 ;
79895
79896   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79897   argp2 = (Dali::AlphaFunction *)jarg2;
79898   if (!argp2) {
79899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79900     return ;
79901   }
79902   arg2 = *argp2;
79903   {
79904     try {
79905       (arg1)->SetScrollSnapAlphaFunction(arg2);
79906     } catch (std::out_of_range& e) {
79907       {
79908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79909       };
79910     } catch (std::exception& e) {
79911       {
79912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79913       };
79914     } catch (Dali::DaliException e) {
79915       {
79916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79917       };
79918     } catch (...) {
79919       {
79920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79921       };
79922     }
79923   }
79924
79925 }
79926
79927
79928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79929   void * jresult ;
79930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79931   Dali::AlphaFunction result;
79932
79933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79934   {
79935     try {
79936       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79937     } catch (std::out_of_range& e) {
79938       {
79939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79940       };
79941     } catch (std::exception& e) {
79942       {
79943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (Dali::DaliException e) {
79946       {
79947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79948       };
79949     } catch (...) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79952       };
79953     }
79954   }
79955
79956   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79957   return jresult;
79958 }
79959
79960
79961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79962   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79963   Dali::AlphaFunction arg2 ;
79964   Dali::AlphaFunction *argp2 ;
79965
79966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79967   argp2 = (Dali::AlphaFunction *)jarg2;
79968   if (!argp2) {
79969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79970     return ;
79971   }
79972   arg2 = *argp2;
79973   {
79974     try {
79975       (arg1)->SetScrollFlickAlphaFunction(arg2);
79976     } catch (std::out_of_range& e) {
79977       {
79978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79979       };
79980     } catch (std::exception& e) {
79981       {
79982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79983       };
79984     } catch (Dali::DaliException e) {
79985       {
79986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79987       };
79988     } catch (...) {
79989       {
79990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79991       };
79992     }
79993   }
79994
79995 }
79996
79997
79998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79999   float jresult ;
80000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80001   float result;
80002
80003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80004   {
80005     try {
80006       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80007     } catch (std::out_of_range& e) {
80008       {
80009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80010       };
80011     } catch (std::exception& e) {
80012       {
80013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80014       };
80015     } catch (Dali::DaliException e) {
80016       {
80017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80018       };
80019     } catch (...) {
80020       {
80021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80022       };
80023     }
80024   }
80025
80026   jresult = result;
80027   return jresult;
80028 }
80029
80030
80031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80032   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80033   float arg2 ;
80034
80035   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80036   arg2 = (float)jarg2;
80037   {
80038     try {
80039       (arg1)->SetScrollSnapDuration(arg2);
80040     } catch (std::out_of_range& e) {
80041       {
80042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80043       };
80044     } catch (std::exception& e) {
80045       {
80046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80047       };
80048     } catch (Dali::DaliException e) {
80049       {
80050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80051       };
80052     } catch (...) {
80053       {
80054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80055       };
80056     }
80057   }
80058
80059 }
80060
80061
80062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80063   float jresult ;
80064   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80065   float result;
80066
80067   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80068   {
80069     try {
80070       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80071     } catch (std::out_of_range& e) {
80072       {
80073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80074       };
80075     } catch (std::exception& e) {
80076       {
80077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80078       };
80079     } catch (Dali::DaliException e) {
80080       {
80081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80082       };
80083     } catch (...) {
80084       {
80085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80086       };
80087     }
80088   }
80089
80090   jresult = result;
80091   return jresult;
80092 }
80093
80094
80095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80097   float arg2 ;
80098
80099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80100   arg2 = (float)jarg2;
80101   {
80102     try {
80103       (arg1)->SetScrollFlickDuration(arg2);
80104     } catch (std::out_of_range& e) {
80105       {
80106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80107       };
80108     } catch (std::exception& e) {
80109       {
80110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80111       };
80112     } catch (Dali::DaliException e) {
80113       {
80114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80115       };
80116     } catch (...) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80119       };
80120     }
80121   }
80122
80123 }
80124
80125
80126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80127   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80128   Dali::Toolkit::RulerPtr arg2 ;
80129   Dali::Toolkit::RulerPtr *argp2 ;
80130
80131   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80132   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80133   if (!argp2) {
80134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80135     return ;
80136   }
80137   arg2 = *argp2;
80138   {
80139     try {
80140       (arg1)->SetRulerX(arg2);
80141     } catch (std::out_of_range& e) {
80142       {
80143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80144       };
80145     } catch (std::exception& e) {
80146       {
80147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80148       };
80149     } catch (Dali::DaliException e) {
80150       {
80151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80152       };
80153     } catch (...) {
80154       {
80155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80156       };
80157     }
80158   }
80159
80160 }
80161
80162
80163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80164   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80165   Dali::Toolkit::RulerPtr arg2 ;
80166   Dali::Toolkit::RulerPtr *argp2 ;
80167
80168   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80169   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80170   if (!argp2) {
80171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80172     return ;
80173   }
80174   arg2 = *argp2;
80175   {
80176     try {
80177       (arg1)->SetRulerY(arg2);
80178     } catch (std::out_of_range& e) {
80179       {
80180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80181       };
80182     } catch (std::exception& e) {
80183       {
80184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80185       };
80186     } catch (Dali::DaliException e) {
80187       {
80188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80189       };
80190     } catch (...) {
80191       {
80192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80193       };
80194     }
80195   }
80196
80197 }
80198
80199
80200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80201   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80202   bool arg2 ;
80203
80204   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80205   arg2 = jarg2 ? true : false;
80206   {
80207     try {
80208       (arg1)->SetScrollSensitive(arg2);
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80216       };
80217     } catch (Dali::DaliException e) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80220       };
80221     } catch (...) {
80222       {
80223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80224       };
80225     }
80226   }
80227
80228 }
80229
80230
80231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80232   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80233   float arg2 ;
80234   float arg3 ;
80235
80236   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80237   arg2 = (float)jarg2;
80238   arg3 = (float)jarg3;
80239   {
80240     try {
80241       (arg1)->SetMaxOvershoot(arg2,arg3);
80242     } catch (std::out_of_range& e) {
80243       {
80244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80245       };
80246     } catch (std::exception& e) {
80247       {
80248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80249       };
80250     } catch (Dali::DaliException e) {
80251       {
80252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80253       };
80254     } catch (...) {
80255       {
80256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80257       };
80258     }
80259   }
80260
80261 }
80262
80263
80264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80266   Dali::AlphaFunction arg2 ;
80267   Dali::AlphaFunction *argp2 ;
80268
80269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80270   argp2 = (Dali::AlphaFunction *)jarg2;
80271   if (!argp2) {
80272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80273     return ;
80274   }
80275   arg2 = *argp2;
80276   {
80277     try {
80278       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80279     } catch (std::out_of_range& e) {
80280       {
80281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80282       };
80283     } catch (std::exception& e) {
80284       {
80285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80286       };
80287     } catch (Dali::DaliException e) {
80288       {
80289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80290       };
80291     } catch (...) {
80292       {
80293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80294       };
80295     }
80296   }
80297
80298 }
80299
80300
80301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80303   float arg2 ;
80304
80305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80306   arg2 = (float)jarg2;
80307   {
80308     try {
80309       (arg1)->SetSnapOvershootDuration(arg2);
80310     } catch (std::out_of_range& e) {
80311       {
80312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80313       };
80314     } catch (std::exception& e) {
80315       {
80316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80317       };
80318     } catch (Dali::DaliException e) {
80319       {
80320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80321       };
80322     } catch (...) {
80323       {
80324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80325       };
80326     }
80327   }
80328
80329 }
80330
80331
80332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80333   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80334   bool arg2 ;
80335
80336   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80337   arg2 = jarg2 ? true : false;
80338   {
80339     try {
80340       (arg1)->SetActorAutoSnap(arg2);
80341     } catch (std::out_of_range& e) {
80342       {
80343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80344       };
80345     } catch (std::exception& e) {
80346       {
80347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80348       };
80349     } catch (Dali::DaliException e) {
80350       {
80351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80352       };
80353     } catch (...) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80356       };
80357     }
80358   }
80359
80360 }
80361
80362
80363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80364   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80365   bool arg2 ;
80366
80367   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80368   arg2 = jarg2 ? true : false;
80369   {
80370     try {
80371       (arg1)->SetWrapMode(arg2);
80372     } catch (std::out_of_range& e) {
80373       {
80374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80375       };
80376     } catch (std::exception& e) {
80377       {
80378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80379       };
80380     } catch (Dali::DaliException e) {
80381       {
80382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80383       };
80384     } catch (...) {
80385       {
80386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80387       };
80388     }
80389   }
80390
80391 }
80392
80393
80394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80395   int jresult ;
80396   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80397   int result;
80398
80399   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80400   {
80401     try {
80402       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80403     } catch (std::out_of_range& e) {
80404       {
80405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80406       };
80407     } catch (std::exception& e) {
80408       {
80409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80410       };
80411     } catch (Dali::DaliException e) {
80412       {
80413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80414       };
80415     } catch (...) {
80416       {
80417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80418       };
80419     }
80420   }
80421
80422   jresult = result;
80423   return jresult;
80424 }
80425
80426
80427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80428   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80429   int arg2 ;
80430
80431   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80432   arg2 = (int)jarg2;
80433   {
80434     try {
80435       (arg1)->SetScrollUpdateDistance(arg2);
80436     } catch (std::out_of_range& e) {
80437       {
80438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80439       };
80440     } catch (std::exception& e) {
80441       {
80442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80443       };
80444     } catch (Dali::DaliException e) {
80445       {
80446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80447       };
80448     } catch (...) {
80449       {
80450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80451       };
80452     }
80453   }
80454
80455 }
80456
80457
80458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80459   unsigned int jresult ;
80460   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80461   bool result;
80462
80463   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80464   {
80465     try {
80466       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80467     } catch (std::out_of_range& e) {
80468       {
80469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80470       };
80471     } catch (std::exception& e) {
80472       {
80473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80474       };
80475     } catch (Dali::DaliException e) {
80476       {
80477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80478       };
80479     } catch (...) {
80480       {
80481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80482       };
80483     }
80484   }
80485
80486   jresult = result;
80487   return jresult;
80488 }
80489
80490
80491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80492   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80493   bool arg2 ;
80494
80495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80496   arg2 = jarg2 ? true : false;
80497   {
80498     try {
80499       (arg1)->SetAxisAutoLock(arg2);
80500     } catch (std::out_of_range& e) {
80501       {
80502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80503       };
80504     } catch (std::exception& e) {
80505       {
80506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80507       };
80508     } catch (Dali::DaliException e) {
80509       {
80510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80511       };
80512     } catch (...) {
80513       {
80514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80515       };
80516     }
80517   }
80518
80519 }
80520
80521
80522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80523   float jresult ;
80524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80525   float result;
80526
80527   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80528   {
80529     try {
80530       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80531     } catch (std::out_of_range& e) {
80532       {
80533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80534       };
80535     } catch (std::exception& e) {
80536       {
80537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80538       };
80539     } catch (Dali::DaliException e) {
80540       {
80541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80542       };
80543     } catch (...) {
80544       {
80545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80546       };
80547     }
80548   }
80549
80550   jresult = result;
80551   return jresult;
80552 }
80553
80554
80555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80556   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80557   float arg2 ;
80558
80559   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80560   arg2 = (float)jarg2;
80561   {
80562     try {
80563       (arg1)->SetAxisAutoLockGradient(arg2);
80564     } catch (std::out_of_range& e) {
80565       {
80566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80567       };
80568     } catch (std::exception& e) {
80569       {
80570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80571       };
80572     } catch (Dali::DaliException e) {
80573       {
80574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80575       };
80576     } catch (...) {
80577       {
80578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80579       };
80580     }
80581   }
80582
80583 }
80584
80585
80586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80587   float jresult ;
80588   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80589   float result;
80590
80591   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80592   {
80593     try {
80594       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80595     } catch (std::out_of_range& e) {
80596       {
80597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80598       };
80599     } catch (std::exception& e) {
80600       {
80601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80602       };
80603     } catch (Dali::DaliException e) {
80604       {
80605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80606       };
80607     } catch (...) {
80608       {
80609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80610       };
80611     }
80612   }
80613
80614   jresult = result;
80615   return jresult;
80616 }
80617
80618
80619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80620   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80621   float arg2 ;
80622
80623   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80624   arg2 = (float)jarg2;
80625   {
80626     try {
80627       (arg1)->SetFrictionCoefficient(arg2);
80628     } catch (std::out_of_range& e) {
80629       {
80630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80631       };
80632     } catch (std::exception& e) {
80633       {
80634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80635       };
80636     } catch (Dali::DaliException e) {
80637       {
80638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80639       };
80640     } catch (...) {
80641       {
80642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80643       };
80644     }
80645   }
80646
80647 }
80648
80649
80650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80651   float jresult ;
80652   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80653   float result;
80654
80655   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80656   {
80657     try {
80658       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80659     } catch (std::out_of_range& e) {
80660       {
80661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80662       };
80663     } catch (std::exception& e) {
80664       {
80665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80666       };
80667     } catch (Dali::DaliException e) {
80668       {
80669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80670       };
80671     } catch (...) {
80672       {
80673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80674       };
80675     }
80676   }
80677
80678   jresult = result;
80679   return jresult;
80680 }
80681
80682
80683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80684   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80685   float arg2 ;
80686
80687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80688   arg2 = (float)jarg2;
80689   {
80690     try {
80691       (arg1)->SetFlickSpeedCoefficient(arg2);
80692     } catch (std::out_of_range& e) {
80693       {
80694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80695       };
80696     } catch (std::exception& e) {
80697       {
80698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80699       };
80700     } catch (Dali::DaliException e) {
80701       {
80702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80703       };
80704     } catch (...) {
80705       {
80706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80707       };
80708     }
80709   }
80710
80711 }
80712
80713
80714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80715   void * jresult ;
80716   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80717   Dali::Vector2 result;
80718
80719   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80720   {
80721     try {
80722       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80723     } catch (std::out_of_range& e) {
80724       {
80725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80726       };
80727     } catch (std::exception& e) {
80728       {
80729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80730       };
80731     } catch (Dali::DaliException e) {
80732       {
80733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80734       };
80735     } catch (...) {
80736       {
80737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80738       };
80739     }
80740   }
80741
80742   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80743   return jresult;
80744 }
80745
80746
80747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80748   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80749   Dali::Vector2 *arg2 = 0 ;
80750
80751   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80752   arg2 = (Dali::Vector2 *)jarg2;
80753   if (!arg2) {
80754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80755     return ;
80756   }
80757   {
80758     try {
80759       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80760     } catch (std::out_of_range& e) {
80761       {
80762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80763       };
80764     } catch (std::exception& e) {
80765       {
80766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80767       };
80768     } catch (Dali::DaliException e) {
80769       {
80770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80771       };
80772     } catch (...) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80775       };
80776     }
80777   }
80778
80779 }
80780
80781
80782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80783   float jresult ;
80784   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80785   float result;
80786
80787   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80788   {
80789     try {
80790       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
80791     } catch (std::out_of_range& e) {
80792       {
80793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80794       };
80795     } catch (std::exception& e) {
80796       {
80797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80798       };
80799     } catch (Dali::DaliException e) {
80800       {
80801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80802       };
80803     } catch (...) {
80804       {
80805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80806       };
80807     }
80808   }
80809
80810   jresult = result;
80811   return jresult;
80812 }
80813
80814
80815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
80816   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80817   float arg2 ;
80818
80819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80820   arg2 = (float)jarg2;
80821   {
80822     try {
80823       (arg1)->SetMinimumSpeedForFlick(arg2);
80824     } catch (std::out_of_range& e) {
80825       {
80826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80827       };
80828     } catch (std::exception& e) {
80829       {
80830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80831       };
80832     } catch (Dali::DaliException e) {
80833       {
80834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80835       };
80836     } catch (...) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80839       };
80840     }
80841   }
80842
80843 }
80844
80845
80846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
80847   float jresult ;
80848   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80849   float result;
80850
80851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80852   {
80853     try {
80854       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80855     } catch (std::out_of_range& e) {
80856       {
80857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80858       };
80859     } catch (std::exception& e) {
80860       {
80861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80862       };
80863     } catch (Dali::DaliException e) {
80864       {
80865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80866       };
80867     } catch (...) {
80868       {
80869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80870       };
80871     }
80872   }
80873
80874   jresult = result;
80875   return jresult;
80876 }
80877
80878
80879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80880   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80881   float arg2 ;
80882
80883   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80884   arg2 = (float)jarg2;
80885   {
80886     try {
80887       (arg1)->SetMaxFlickSpeed(arg2);
80888     } catch (std::out_of_range& e) {
80889       {
80890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80891       };
80892     } catch (std::exception& e) {
80893       {
80894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80895       };
80896     } catch (Dali::DaliException e) {
80897       {
80898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80899       };
80900     } catch (...) {
80901       {
80902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80903       };
80904     }
80905   }
80906
80907 }
80908
80909
80910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80911   void * jresult ;
80912   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80913   Dali::Vector2 result;
80914
80915   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80916   {
80917     try {
80918       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80919     } catch (std::out_of_range& e) {
80920       {
80921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80922       };
80923     } catch (std::exception& e) {
80924       {
80925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80926       };
80927     } catch (Dali::DaliException e) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80930       };
80931     } catch (...) {
80932       {
80933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80934       };
80935     }
80936   }
80937
80938   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80939   return jresult;
80940 }
80941
80942
80943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80944   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80945   Dali::Vector2 arg2 ;
80946   Dali::Vector2 *argp2 ;
80947
80948   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80949   argp2 = (Dali::Vector2 *)jarg2;
80950   if (!argp2) {
80951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80952     return ;
80953   }
80954   arg2 = *argp2;
80955   {
80956     try {
80957       (arg1)->SetWheelScrollDistanceStep(arg2);
80958     } catch (std::out_of_range& e) {
80959       {
80960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80961       };
80962     } catch (std::exception& e) {
80963       {
80964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80965       };
80966     } catch (Dali::DaliException e) {
80967       {
80968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80969       };
80970     } catch (...) {
80971       {
80972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80973       };
80974     }
80975   }
80976
80977 }
80978
80979
80980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80981   void * jresult ;
80982   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80983   Dali::Vector2 result;
80984
80985   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80986   {
80987     try {
80988       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80989     } catch (std::out_of_range& e) {
80990       {
80991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80992       };
80993     } catch (std::exception& e) {
80994       {
80995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80996       };
80997     } catch (Dali::DaliException e) {
80998       {
80999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81000       };
81001     } catch (...) {
81002       {
81003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81004       };
81005     }
81006   }
81007
81008   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81009   return jresult;
81010 }
81011
81012
81013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81014   unsigned int jresult ;
81015   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81016   unsigned int result;
81017
81018   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81019   {
81020     try {
81021       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81022     } catch (std::out_of_range& e) {
81023       {
81024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81025       };
81026     } catch (std::exception& e) {
81027       {
81028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81029       };
81030     } catch (Dali::DaliException e) {
81031       {
81032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81033       };
81034     } catch (...) {
81035       {
81036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81037       };
81038     }
81039   }
81040
81041   jresult = result;
81042   return jresult;
81043 }
81044
81045
81046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81048   Dali::Vector2 *arg2 = 0 ;
81049
81050   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81051   arg2 = (Dali::Vector2 *)jarg2;
81052   if (!arg2) {
81053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81054     return ;
81055   }
81056   {
81057     try {
81058       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81059     } catch (std::out_of_range& e) {
81060       {
81061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81062       };
81063     } catch (std::exception& e) {
81064       {
81065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81066       };
81067     } catch (Dali::DaliException e) {
81068       {
81069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81070       };
81071     } catch (...) {
81072       {
81073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81074       };
81075     }
81076   }
81077
81078 }
81079
81080
81081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81083   Dali::Vector2 *arg2 = 0 ;
81084   float arg3 ;
81085
81086   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81087   arg2 = (Dali::Vector2 *)jarg2;
81088   if (!arg2) {
81089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81090     return ;
81091   }
81092   arg3 = (float)jarg3;
81093   {
81094     try {
81095       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81096     } catch (std::out_of_range& e) {
81097       {
81098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81099       };
81100     } catch (std::exception& e) {
81101       {
81102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81103       };
81104     } catch (Dali::DaliException e) {
81105       {
81106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81107       };
81108     } catch (...) {
81109       {
81110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81111       };
81112     }
81113   }
81114
81115 }
81116
81117
81118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81119   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81120   Dali::Vector2 *arg2 = 0 ;
81121   float arg3 ;
81122   Dali::AlphaFunction arg4 ;
81123   Dali::AlphaFunction *argp4 ;
81124
81125   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81126   arg2 = (Dali::Vector2 *)jarg2;
81127   if (!arg2) {
81128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81129     return ;
81130   }
81131   arg3 = (float)jarg3;
81132   argp4 = (Dali::AlphaFunction *)jarg4;
81133   if (!argp4) {
81134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81135     return ;
81136   }
81137   arg4 = *argp4;
81138   {
81139     try {
81140       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81141     } catch (std::out_of_range& e) {
81142       {
81143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81144       };
81145     } catch (std::exception& e) {
81146       {
81147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81148       };
81149     } catch (Dali::DaliException e) {
81150       {
81151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81152       };
81153     } catch (...) {
81154       {
81155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81156       };
81157     }
81158   }
81159
81160 }
81161
81162
81163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81164   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81165   Dali::Vector2 *arg2 = 0 ;
81166   float arg3 ;
81167   Dali::Toolkit::DirectionBias arg4 ;
81168   Dali::Toolkit::DirectionBias arg5 ;
81169
81170   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81171   arg2 = (Dali::Vector2 *)jarg2;
81172   if (!arg2) {
81173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81174     return ;
81175   }
81176   arg3 = (float)jarg3;
81177   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81178   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81179   {
81180     try {
81181       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81182     } catch (std::out_of_range& e) {
81183       {
81184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81185       };
81186     } catch (std::exception& e) {
81187       {
81188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81189       };
81190     } catch (Dali::DaliException e) {
81191       {
81192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81193       };
81194     } catch (...) {
81195       {
81196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81197       };
81198     }
81199   }
81200
81201 }
81202
81203
81204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81205   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81206   Dali::Vector2 *arg2 = 0 ;
81207   float arg3 ;
81208   Dali::AlphaFunction arg4 ;
81209   Dali::Toolkit::DirectionBias arg5 ;
81210   Dali::Toolkit::DirectionBias arg6 ;
81211   Dali::AlphaFunction *argp4 ;
81212
81213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81214   arg2 = (Dali::Vector2 *)jarg2;
81215   if (!arg2) {
81216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81217     return ;
81218   }
81219   arg3 = (float)jarg3;
81220   argp4 = (Dali::AlphaFunction *)jarg4;
81221   if (!argp4) {
81222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81223     return ;
81224   }
81225   arg4 = *argp4;
81226   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81227   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81228   {
81229     try {
81230       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81231     } catch (std::out_of_range& e) {
81232       {
81233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81234       };
81235     } catch (std::exception& e) {
81236       {
81237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81238       };
81239     } catch (Dali::DaliException e) {
81240       {
81241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81242       };
81243     } catch (...) {
81244       {
81245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81246       };
81247     }
81248   }
81249
81250 }
81251
81252
81253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81254   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81255   unsigned int arg2 ;
81256
81257   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81258   arg2 = (unsigned int)jarg2;
81259   {
81260     try {
81261       (arg1)->ScrollTo(arg2);
81262     } catch (std::out_of_range& e) {
81263       {
81264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81265       };
81266     } catch (std::exception& e) {
81267       {
81268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81269       };
81270     } catch (Dali::DaliException e) {
81271       {
81272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81273       };
81274     } catch (...) {
81275       {
81276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81277       };
81278     }
81279   }
81280
81281 }
81282
81283
81284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81285   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81286   unsigned int arg2 ;
81287   float arg3 ;
81288
81289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81290   arg2 = (unsigned int)jarg2;
81291   arg3 = (float)jarg3;
81292   {
81293     try {
81294       (arg1)->ScrollTo(arg2,arg3);
81295     } catch (std::out_of_range& e) {
81296       {
81297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81298       };
81299     } catch (std::exception& e) {
81300       {
81301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81302       };
81303     } catch (Dali::DaliException e) {
81304       {
81305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81306       };
81307     } catch (...) {
81308       {
81309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81310       };
81311     }
81312   }
81313
81314 }
81315
81316
81317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81319   unsigned int arg2 ;
81320   float arg3 ;
81321   Dali::Toolkit::DirectionBias arg4 ;
81322
81323   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81324   arg2 = (unsigned int)jarg2;
81325   arg3 = (float)jarg3;
81326   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81327   {
81328     try {
81329       (arg1)->ScrollTo(arg2,arg3,arg4);
81330     } catch (std::out_of_range& e) {
81331       {
81332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81333       };
81334     } catch (std::exception& e) {
81335       {
81336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81337       };
81338     } catch (Dali::DaliException e) {
81339       {
81340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81341       };
81342     } catch (...) {
81343       {
81344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81345       };
81346     }
81347   }
81348
81349 }
81350
81351
81352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81353   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81354   Dali::Actor *arg2 = 0 ;
81355
81356   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81357   arg2 = (Dali::Actor *)jarg2;
81358   if (!arg2) {
81359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81360     return ;
81361   }
81362   {
81363     try {
81364       (arg1)->ScrollTo(*arg2);
81365     } catch (std::out_of_range& e) {
81366       {
81367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81368       };
81369     } catch (std::exception& e) {
81370       {
81371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81372       };
81373     } catch (Dali::DaliException e) {
81374       {
81375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81376       };
81377     } catch (...) {
81378       {
81379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81380       };
81381     }
81382   }
81383
81384 }
81385
81386
81387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81388   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81389   Dali::Actor *arg2 = 0 ;
81390   float arg3 ;
81391
81392   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81393   arg2 = (Dali::Actor *)jarg2;
81394   if (!arg2) {
81395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81396     return ;
81397   }
81398   arg3 = (float)jarg3;
81399   {
81400     try {
81401       (arg1)->ScrollTo(*arg2,arg3);
81402     } catch (std::out_of_range& e) {
81403       {
81404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81405       };
81406     } catch (std::exception& e) {
81407       {
81408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81409       };
81410     } catch (Dali::DaliException e) {
81411       {
81412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81413       };
81414     } catch (...) {
81415       {
81416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81417       };
81418     }
81419   }
81420
81421 }
81422
81423
81424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81425   unsigned int jresult ;
81426   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81427   bool result;
81428
81429   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81430   {
81431     try {
81432       result = (bool)(arg1)->ScrollToSnapPoint();
81433     } catch (std::out_of_range& e) {
81434       {
81435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81436       };
81437     } catch (std::exception& e) {
81438       {
81439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81440       };
81441     } catch (Dali::DaliException e) {
81442       {
81443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81444       };
81445     } catch (...) {
81446       {
81447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81448       };
81449     }
81450   }
81451
81452   jresult = result;
81453   return jresult;
81454 }
81455
81456
81457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81458   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81459   Dali::Constraint arg2 ;
81460   Dali::Constraint *argp2 ;
81461
81462   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81463   argp2 = (Dali::Constraint *)jarg2;
81464   if (!argp2) {
81465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81466     return ;
81467   }
81468   arg2 = *argp2;
81469   {
81470     try {
81471       (arg1)->ApplyConstraintToChildren(arg2);
81472     } catch (std::out_of_range& e) {
81473       {
81474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81475       };
81476     } catch (std::exception& e) {
81477       {
81478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81479       };
81480     } catch (Dali::DaliException e) {
81481       {
81482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81483       };
81484     } catch (...) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81487       };
81488     }
81489   }
81490
81491 }
81492
81493
81494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81495   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81496
81497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81498   {
81499     try {
81500       (arg1)->RemoveConstraintsFromChildren();
81501     } catch (std::out_of_range& e) {
81502       {
81503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81504       };
81505     } catch (std::exception& e) {
81506       {
81507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81508       };
81509     } catch (Dali::DaliException e) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81512       };
81513     } catch (...) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81516       };
81517     }
81518   }
81519
81520 }
81521
81522
81523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81525   Dali::Toolkit::ScrollViewEffect arg2 ;
81526   Dali::Toolkit::ScrollViewEffect *argp2 ;
81527
81528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81529   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81530   if (!argp2) {
81531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81532     return ;
81533   }
81534   arg2 = *argp2;
81535   {
81536     try {
81537       (arg1)->ApplyEffect(arg2);
81538     } catch (std::out_of_range& e) {
81539       {
81540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81541       };
81542     } catch (std::exception& e) {
81543       {
81544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81545       };
81546     } catch (Dali::DaliException e) {
81547       {
81548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81549       };
81550     } catch (...) {
81551       {
81552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81553       };
81554     }
81555   }
81556
81557 }
81558
81559
81560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81561   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81562   Dali::Toolkit::ScrollViewEffect arg2 ;
81563   Dali::Toolkit::ScrollViewEffect *argp2 ;
81564
81565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81566   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81567   if (!argp2) {
81568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81569     return ;
81570   }
81571   arg2 = *argp2;
81572   {
81573     try {
81574       (arg1)->RemoveEffect(arg2);
81575     } catch (std::out_of_range& e) {
81576       {
81577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81578       };
81579     } catch (std::exception& e) {
81580       {
81581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81582       };
81583     } catch (Dali::DaliException e) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81586       };
81587     } catch (...) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81590       };
81591     }
81592   }
81593
81594 }
81595
81596
81597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81598   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81599
81600   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81601   {
81602     try {
81603       (arg1)->RemoveAllEffects();
81604     } catch (std::out_of_range& e) {
81605       {
81606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81607       };
81608     } catch (std::exception& e) {
81609       {
81610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81611       };
81612     } catch (Dali::DaliException e) {
81613       {
81614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81615       };
81616     } catch (...) {
81617       {
81618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81619       };
81620     }
81621   }
81622
81623 }
81624
81625
81626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81627   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81628   Dali::Actor arg2 ;
81629   Dali::Actor *argp2 ;
81630
81631   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81632   argp2 = (Dali::Actor *)jarg2;
81633   if (!argp2) {
81634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81635     return ;
81636   }
81637   arg2 = *argp2;
81638   {
81639     try {
81640       (arg1)->BindActor(arg2);
81641     } catch (std::out_of_range& e) {
81642       {
81643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81644       };
81645     } catch (std::exception& e) {
81646       {
81647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81648       };
81649     } catch (Dali::DaliException e) {
81650       {
81651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81652       };
81653     } catch (...) {
81654       {
81655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81656       };
81657     }
81658   }
81659
81660 }
81661
81662
81663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81664   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81665   Dali::Actor arg2 ;
81666   Dali::Actor *argp2 ;
81667
81668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81669   argp2 = (Dali::Actor *)jarg2;
81670   if (!argp2) {
81671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81672     return ;
81673   }
81674   arg2 = *argp2;
81675   {
81676     try {
81677       (arg1)->UnbindActor(arg2);
81678     } catch (std::out_of_range& e) {
81679       {
81680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81681       };
81682     } catch (std::exception& e) {
81683       {
81684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81685       };
81686     } catch (Dali::DaliException e) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81689       };
81690     } catch (...) {
81691       {
81692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81693       };
81694     }
81695   }
81696
81697 }
81698
81699
81700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81702   Dali::Radian arg2 ;
81703   Dali::Radian arg3 ;
81704   Dali::Radian *argp2 ;
81705   Dali::Radian *argp3 ;
81706
81707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81708   argp2 = (Dali::Radian *)jarg2;
81709   if (!argp2) {
81710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81711     return ;
81712   }
81713   arg2 = *argp2;
81714   argp3 = (Dali::Radian *)jarg3;
81715   if (!argp3) {
81716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81717     return ;
81718   }
81719   arg3 = *argp3;
81720   {
81721     try {
81722       (arg1)->SetScrollingDirection(arg2,arg3);
81723     } catch (std::out_of_range& e) {
81724       {
81725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81726       };
81727     } catch (std::exception& e) {
81728       {
81729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81730       };
81731     } catch (Dali::DaliException e) {
81732       {
81733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81734       };
81735     } catch (...) {
81736       {
81737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81738       };
81739     }
81740   }
81741
81742 }
81743
81744
81745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81747   Dali::Radian arg2 ;
81748   Dali::Radian *argp2 ;
81749
81750   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81751   argp2 = (Dali::Radian *)jarg2;
81752   if (!argp2) {
81753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81754     return ;
81755   }
81756   arg2 = *argp2;
81757   {
81758     try {
81759       (arg1)->SetScrollingDirection(arg2);
81760     } catch (std::out_of_range& e) {
81761       {
81762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81763       };
81764     } catch (std::exception& e) {
81765       {
81766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81767       };
81768     } catch (Dali::DaliException e) {
81769       {
81770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81771       };
81772     } catch (...) {
81773       {
81774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81775       };
81776     }
81777   }
81778
81779 }
81780
81781
81782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81783   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81784   Dali::Radian arg2 ;
81785   Dali::Radian *argp2 ;
81786
81787   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81788   argp2 = (Dali::Radian *)jarg2;
81789   if (!argp2) {
81790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81791     return ;
81792   }
81793   arg2 = *argp2;
81794   {
81795     try {
81796       (arg1)->RemoveScrollingDirection(arg2);
81797     } catch (std::out_of_range& e) {
81798       {
81799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81800       };
81801     } catch (std::exception& e) {
81802       {
81803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81804       };
81805     } catch (Dali::DaliException e) {
81806       {
81807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81808       };
81809     } catch (...) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81812       };
81813     }
81814   }
81815
81816 }
81817
81818
81819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
81820   void * jresult ;
81821   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81822   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
81823
81824   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81825   {
81826     try {
81827       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
81828     } catch (std::out_of_range& e) {
81829       {
81830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81831       };
81832     } catch (std::exception& e) {
81833       {
81834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81835       };
81836     } catch (Dali::DaliException e) {
81837       {
81838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81839       };
81840     } catch (...) {
81841       {
81842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81843       };
81844     }
81845   }
81846
81847   jresult = (void *)result;
81848   return jresult;
81849 }
81850
81851
81852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81853   int jresult ;
81854   int result;
81855
81856   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81857   jresult = (int)result;
81858   return jresult;
81859 }
81860
81861
81862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81863   int jresult ;
81864   int result;
81865
81866   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81867   jresult = (int)result;
81868   return jresult;
81869 }
81870
81871
81872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81873   int jresult ;
81874   int result;
81875
81876   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81877   jresult = (int)result;
81878   return jresult;
81879 }
81880
81881
81882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81883   int jresult ;
81884   int result;
81885
81886   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81887   jresult = (int)result;
81888   return jresult;
81889 }
81890
81891
81892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81893   int jresult ;
81894   int result;
81895
81896   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81897   jresult = (int)result;
81898   return jresult;
81899 }
81900
81901
81902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81903   void * jresult ;
81904   Dali::Toolkit::TableView::Property *result = 0 ;
81905
81906   {
81907     try {
81908       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81909     } catch (std::out_of_range& e) {
81910       {
81911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81912       };
81913     } catch (std::exception& e) {
81914       {
81915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81916       };
81917     } catch (Dali::DaliException e) {
81918       {
81919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81920       };
81921     } catch (...) {
81922       {
81923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81924       };
81925     }
81926   }
81927
81928   jresult = (void *)result;
81929   return jresult;
81930 }
81931
81932
81933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81934   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81935
81936   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81937   {
81938     try {
81939       delete arg1;
81940     } catch (std::out_of_range& e) {
81941       {
81942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81943       };
81944     } catch (std::exception& e) {
81945       {
81946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81947       };
81948     } catch (Dali::DaliException e) {
81949       {
81950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81951       };
81952     } catch (...) {
81953       {
81954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81955       };
81956     }
81957   }
81958
81959 }
81960
81961
81962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81963   int jresult ;
81964   int result;
81965
81966   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81967   jresult = (int)result;
81968   return jresult;
81969 }
81970
81971
81972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81973   int jresult ;
81974   int result;
81975
81976   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81977   jresult = (int)result;
81978   return jresult;
81979 }
81980
81981
81982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81983   int jresult ;
81984   int result;
81985
81986   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81987   jresult = (int)result;
81988   return jresult;
81989 }
81990
81991
81992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81993   int jresult ;
81994   int result;
81995
81996   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81997   jresult = (int)result;
81998   return jresult;
81999 }
82000
82001
82002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82003   int jresult ;
82004   int result;
82005
82006   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82007   jresult = (int)result;
82008   return jresult;
82009 }
82010
82011
82012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82013   void * jresult ;
82014   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82015
82016   {
82017     try {
82018       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82019     } catch (std::out_of_range& e) {
82020       {
82021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82022       };
82023     } catch (std::exception& e) {
82024       {
82025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82026       };
82027     } catch (Dali::DaliException e) {
82028       {
82029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82030       };
82031     } catch (...) {
82032       {
82033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82034       };
82035     }
82036   }
82037
82038   jresult = (void *)result;
82039   return jresult;
82040 }
82041
82042
82043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82044   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82045
82046   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82047   {
82048     try {
82049       delete arg1;
82050     } catch (std::out_of_range& e) {
82051       {
82052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82053       };
82054     } catch (std::exception& e) {
82055       {
82056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82057       };
82058     } catch (Dali::DaliException e) {
82059       {
82060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82061       };
82062     } catch (...) {
82063       {
82064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82065       };
82066     }
82067   }
82068
82069 }
82070
82071
82072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82073   void * jresult ;
82074   unsigned int arg1 ;
82075   unsigned int arg2 ;
82076   unsigned int arg3 ;
82077   unsigned int arg4 ;
82078   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82079
82080   arg1 = (unsigned int)jarg1;
82081   arg2 = (unsigned int)jarg2;
82082   arg3 = (unsigned int)jarg3;
82083   arg4 = (unsigned int)jarg4;
82084   {
82085     try {
82086       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82087     } catch (std::out_of_range& e) {
82088       {
82089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82090       };
82091     } catch (std::exception& e) {
82092       {
82093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82094       };
82095     } catch (Dali::DaliException e) {
82096       {
82097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82098       };
82099     } catch (...) {
82100       {
82101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82102       };
82103     }
82104   }
82105
82106   jresult = (void *)result;
82107   return jresult;
82108 }
82109
82110
82111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82112   void * jresult ;
82113   unsigned int arg1 ;
82114   unsigned int arg2 ;
82115   unsigned int arg3 ;
82116   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82117
82118   arg1 = (unsigned int)jarg1;
82119   arg2 = (unsigned int)jarg2;
82120   arg3 = (unsigned int)jarg3;
82121   {
82122     try {
82123       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82124     } catch (std::out_of_range& e) {
82125       {
82126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82127       };
82128     } catch (std::exception& e) {
82129       {
82130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82131       };
82132     } catch (Dali::DaliException e) {
82133       {
82134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82135       };
82136     } catch (...) {
82137       {
82138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82139       };
82140     }
82141   }
82142
82143   jresult = (void *)result;
82144   return jresult;
82145 }
82146
82147
82148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82149   void * jresult ;
82150   unsigned int arg1 ;
82151   unsigned int arg2 ;
82152   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82153
82154   arg1 = (unsigned int)jarg1;
82155   arg2 = (unsigned int)jarg2;
82156   {
82157     try {
82158       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82159     } catch (std::out_of_range& e) {
82160       {
82161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82162       };
82163     } catch (std::exception& e) {
82164       {
82165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82166       };
82167     } catch (Dali::DaliException e) {
82168       {
82169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82170       };
82171     } catch (...) {
82172       {
82173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82174       };
82175     }
82176   }
82177
82178   jresult = (void *)result;
82179   return jresult;
82180 }
82181
82182
82183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82184   void * jresult ;
82185   unsigned int arg1 ;
82186   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82187
82188   arg1 = (unsigned int)jarg1;
82189   {
82190     try {
82191       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82192     } catch (std::out_of_range& e) {
82193       {
82194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82195       };
82196     } catch (std::exception& e) {
82197       {
82198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82199       };
82200     } catch (Dali::DaliException e) {
82201       {
82202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82203       };
82204     } catch (...) {
82205       {
82206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82207       };
82208     }
82209   }
82210
82211   jresult = (void *)result;
82212   return jresult;
82213 }
82214
82215
82216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82217   void * jresult ;
82218   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82219
82220   {
82221     try {
82222       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82223     } catch (std::out_of_range& e) {
82224       {
82225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82226       };
82227     } catch (std::exception& e) {
82228       {
82229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82230       };
82231     } catch (Dali::DaliException e) {
82232       {
82233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82234       };
82235     } catch (...) {
82236       {
82237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82238       };
82239     }
82240   }
82241
82242   jresult = (void *)result;
82243   return jresult;
82244 }
82245
82246
82247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82248   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82249   unsigned int arg2 ;
82250
82251   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82252   arg2 = (unsigned int)jarg2;
82253   if (arg1) (arg1)->rowIndex = arg2;
82254 }
82255
82256
82257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82258   unsigned int jresult ;
82259   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82260   unsigned int result;
82261
82262   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82263   result = (unsigned int) ((arg1)->rowIndex);
82264   jresult = result;
82265   return jresult;
82266 }
82267
82268
82269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82270   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82271   unsigned int arg2 ;
82272
82273   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82274   arg2 = (unsigned int)jarg2;
82275   if (arg1) (arg1)->columnIndex = arg2;
82276 }
82277
82278
82279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82280   unsigned int jresult ;
82281   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82282   unsigned int result;
82283
82284   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82285   result = (unsigned int) ((arg1)->columnIndex);
82286   jresult = result;
82287   return jresult;
82288 }
82289
82290
82291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82292   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82293   unsigned int arg2 ;
82294
82295   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82296   arg2 = (unsigned int)jarg2;
82297   if (arg1) (arg1)->rowSpan = arg2;
82298 }
82299
82300
82301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82302   unsigned int jresult ;
82303   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82304   unsigned int result;
82305
82306   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82307   result = (unsigned int) ((arg1)->rowSpan);
82308   jresult = result;
82309   return jresult;
82310 }
82311
82312
82313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82314   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82315   unsigned int arg2 ;
82316
82317   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82318   arg2 = (unsigned int)jarg2;
82319   if (arg1) (arg1)->columnSpan = arg2;
82320 }
82321
82322
82323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82324   unsigned int jresult ;
82325   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82326   unsigned int result;
82327
82328   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82329   result = (unsigned int) ((arg1)->columnSpan);
82330   jresult = result;
82331   return jresult;
82332 }
82333
82334
82335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82336   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82337
82338   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82339   {
82340     try {
82341       delete arg1;
82342     } catch (std::out_of_range& e) {
82343       {
82344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82345       };
82346     } catch (std::exception& e) {
82347       {
82348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82349       };
82350     } catch (Dali::DaliException e) {
82351       {
82352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82353       };
82354     } catch (...) {
82355       {
82356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82357       };
82358     }
82359   }
82360
82361 }
82362
82363
82364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82365   void * jresult ;
82366   Dali::Toolkit::TableView *result = 0 ;
82367
82368   {
82369     try {
82370       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82371     } catch (std::out_of_range& e) {
82372       {
82373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82374       };
82375     } catch (std::exception& e) {
82376       {
82377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82378       };
82379     } catch (Dali::DaliException e) {
82380       {
82381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82382       };
82383     } catch (...) {
82384       {
82385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82386       };
82387     }
82388   }
82389
82390   jresult = (void *)result;
82391   return jresult;
82392 }
82393
82394
82395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82396   void * jresult ;
82397   Dali::Toolkit::TableView *arg1 = 0 ;
82398   Dali::Toolkit::TableView *result = 0 ;
82399
82400   arg1 = (Dali::Toolkit::TableView *)jarg1;
82401   if (!arg1) {
82402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82403     return 0;
82404   }
82405   {
82406     try {
82407       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82408     } catch (std::out_of_range& e) {
82409       {
82410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82411       };
82412     } catch (std::exception& e) {
82413       {
82414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82415       };
82416     } catch (Dali::DaliException e) {
82417       {
82418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82419       };
82420     } catch (...) {
82421       {
82422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82423       };
82424     }
82425   }
82426
82427   jresult = (void *)result;
82428   return jresult;
82429 }
82430
82431
82432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82433   void * jresult ;
82434   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82435   Dali::Toolkit::TableView *arg2 = 0 ;
82436   Dali::Toolkit::TableView *result = 0 ;
82437
82438   arg1 = (Dali::Toolkit::TableView *)jarg1;
82439   arg2 = (Dali::Toolkit::TableView *)jarg2;
82440   if (!arg2) {
82441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82442     return 0;
82443   }
82444   {
82445     try {
82446       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82447     } catch (std::out_of_range& e) {
82448       {
82449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82450       };
82451     } catch (std::exception& e) {
82452       {
82453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82454       };
82455     } catch (Dali::DaliException e) {
82456       {
82457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82458       };
82459     } catch (...) {
82460       {
82461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82462       };
82463     }
82464   }
82465
82466   jresult = (void *)result;
82467   return jresult;
82468 }
82469
82470
82471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82472   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82473
82474   arg1 = (Dali::Toolkit::TableView *)jarg1;
82475   {
82476     try {
82477       delete arg1;
82478     } catch (std::out_of_range& e) {
82479       {
82480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82481       };
82482     } catch (std::exception& e) {
82483       {
82484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82485       };
82486     } catch (Dali::DaliException e) {
82487       {
82488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82489       };
82490     } catch (...) {
82491       {
82492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82493       };
82494     }
82495   }
82496
82497 }
82498
82499
82500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82501   void * jresult ;
82502   unsigned int arg1 ;
82503   unsigned int arg2 ;
82504   Dali::Toolkit::TableView result;
82505
82506   arg1 = (unsigned int)jarg1;
82507   arg2 = (unsigned int)jarg2;
82508   {
82509     try {
82510       result = Dali::Toolkit::TableView::New(arg1,arg2);
82511     } catch (std::out_of_range& e) {
82512       {
82513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82514       };
82515     } catch (std::exception& e) {
82516       {
82517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82518       };
82519     } catch (Dali::DaliException e) {
82520       {
82521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82522       };
82523     } catch (...) {
82524       {
82525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82526       };
82527     }
82528   }
82529
82530   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82531   return jresult;
82532 }
82533
82534
82535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82536   void * jresult ;
82537   Dali::BaseHandle arg1 ;
82538   Dali::BaseHandle *argp1 ;
82539   Dali::Toolkit::TableView result;
82540
82541   argp1 = (Dali::BaseHandle *)jarg1;
82542   if (!argp1) {
82543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82544     return 0;
82545   }
82546   arg1 = *argp1;
82547   {
82548     try {
82549       result = Dali::Toolkit::TableView::DownCast(arg1);
82550     } catch (std::out_of_range& e) {
82551       {
82552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82553       };
82554     } catch (std::exception& e) {
82555       {
82556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82557       };
82558     } catch (Dali::DaliException e) {
82559       {
82560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82561       };
82562     } catch (...) {
82563       {
82564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82565       };
82566     }
82567   }
82568
82569   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82570   return jresult;
82571 }
82572
82573
82574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82575   unsigned int jresult ;
82576   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82577   Dali::Actor arg2 ;
82578   Dali::Toolkit::TableView::CellPosition arg3 ;
82579   Dali::Actor *argp2 ;
82580   Dali::Toolkit::TableView::CellPosition *argp3 ;
82581   bool result;
82582
82583   arg1 = (Dali::Toolkit::TableView *)jarg1;
82584   argp2 = (Dali::Actor *)jarg2;
82585   if (!argp2) {
82586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82587     return 0;
82588   }
82589   arg2 = *argp2;
82590   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82591   if (!argp3) {
82592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82593     return 0;
82594   }
82595   arg3 = *argp3;
82596   {
82597     try {
82598       result = (bool)(arg1)->AddChild(arg2,arg3);
82599     } catch (std::out_of_range& e) {
82600       {
82601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82602       };
82603     } catch (std::exception& e) {
82604       {
82605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82606       };
82607     } catch (Dali::DaliException e) {
82608       {
82609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82610       };
82611     } catch (...) {
82612       {
82613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82614       };
82615     }
82616   }
82617
82618   jresult = result;
82619   return jresult;
82620 }
82621
82622
82623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82624   void * jresult ;
82625   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82626   Dali::Toolkit::TableView::CellPosition arg2 ;
82627   Dali::Toolkit::TableView::CellPosition *argp2 ;
82628   Dali::Actor result;
82629
82630   arg1 = (Dali::Toolkit::TableView *)jarg1;
82631   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82632   if (!argp2) {
82633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82634     return 0;
82635   }
82636   arg2 = *argp2;
82637   {
82638     try {
82639       result = (arg1)->GetChildAt(arg2);
82640     } catch (std::out_of_range& e) {
82641       {
82642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82643       };
82644     } catch (std::exception& e) {
82645       {
82646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82647       };
82648     } catch (Dali::DaliException e) {
82649       {
82650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82651       };
82652     } catch (...) {
82653       {
82654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82655       };
82656     }
82657   }
82658
82659   jresult = new Dali::Actor((const Dali::Actor &)result);
82660   return jresult;
82661 }
82662
82663
82664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82665   void * jresult ;
82666   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82667   Dali::Toolkit::TableView::CellPosition arg2 ;
82668   Dali::Toolkit::TableView::CellPosition *argp2 ;
82669   Dali::Actor result;
82670
82671   arg1 = (Dali::Toolkit::TableView *)jarg1;
82672   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82673   if (!argp2) {
82674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82675     return 0;
82676   }
82677   arg2 = *argp2;
82678   {
82679     try {
82680       result = (arg1)->RemoveChildAt(arg2);
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 = new Dali::Actor((const Dali::Actor &)result);
82701   return jresult;
82702 }
82703
82704
82705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82706   unsigned int jresult ;
82707   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82708   Dali::Actor arg2 ;
82709   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82710   Dali::Actor *argp2 ;
82711   bool result;
82712
82713   arg1 = (Dali::Toolkit::TableView *)jarg1;
82714   argp2 = (Dali::Actor *)jarg2;
82715   if (!argp2) {
82716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82717     return 0;
82718   }
82719   arg2 = *argp2;
82720   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82721   if (!arg3) {
82722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82723     return 0;
82724   }
82725   {
82726     try {
82727       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82728     } catch (std::out_of_range& e) {
82729       {
82730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82731       };
82732     } catch (std::exception& e) {
82733       {
82734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82735       };
82736     } catch (Dali::DaliException e) {
82737       {
82738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82739       };
82740     } catch (...) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82743       };
82744     }
82745   }
82746
82747   jresult = result;
82748   return jresult;
82749 }
82750
82751
82752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82753   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82754   unsigned int arg2 ;
82755
82756   arg1 = (Dali::Toolkit::TableView *)jarg1;
82757   arg2 = (unsigned int)jarg2;
82758   {
82759     try {
82760       (arg1)->InsertRow(arg2);
82761     } catch (std::out_of_range& e) {
82762       {
82763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82764       };
82765     } catch (std::exception& e) {
82766       {
82767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82768       };
82769     } catch (Dali::DaliException e) {
82770       {
82771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82772       };
82773     } catch (...) {
82774       {
82775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82776       };
82777     }
82778   }
82779
82780 }
82781
82782
82783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82784   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82785   unsigned int arg2 ;
82786
82787   arg1 = (Dali::Toolkit::TableView *)jarg1;
82788   arg2 = (unsigned int)jarg2;
82789   {
82790     try {
82791       (arg1)->DeleteRow(arg2);
82792     } catch (std::out_of_range& e) {
82793       {
82794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82795       };
82796     } catch (std::exception& e) {
82797       {
82798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82799       };
82800     } catch (Dali::DaliException e) {
82801       {
82802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82803       };
82804     } catch (...) {
82805       {
82806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82807       };
82808     }
82809   }
82810
82811 }
82812
82813
82814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82815   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82816   unsigned int arg2 ;
82817   std::vector< Dali::Actor > *arg3 = 0 ;
82818
82819   arg1 = (Dali::Toolkit::TableView *)jarg1;
82820   arg2 = (unsigned int)jarg2;
82821   arg3 = (std::vector< Dali::Actor > *)jarg3;
82822   if (!arg3) {
82823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82824     return ;
82825   }
82826   {
82827     try {
82828       (arg1)->DeleteRow(arg2,*arg3);
82829     } catch (std::out_of_range& e) {
82830       {
82831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82832       };
82833     } catch (std::exception& e) {
82834       {
82835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82836       };
82837     } catch (Dali::DaliException e) {
82838       {
82839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82840       };
82841     } catch (...) {
82842       {
82843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82844       };
82845     }
82846   }
82847
82848 }
82849
82850
82851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82852   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82853   unsigned int arg2 ;
82854
82855   arg1 = (Dali::Toolkit::TableView *)jarg1;
82856   arg2 = (unsigned int)jarg2;
82857   {
82858     try {
82859       (arg1)->InsertColumn(arg2);
82860     } catch (std::out_of_range& e) {
82861       {
82862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82863       };
82864     } catch (std::exception& e) {
82865       {
82866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82867       };
82868     } catch (Dali::DaliException e) {
82869       {
82870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82871       };
82872     } catch (...) {
82873       {
82874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82875       };
82876     }
82877   }
82878
82879 }
82880
82881
82882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82883   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82884   unsigned int arg2 ;
82885
82886   arg1 = (Dali::Toolkit::TableView *)jarg1;
82887   arg2 = (unsigned int)jarg2;
82888   {
82889     try {
82890       (arg1)->DeleteColumn(arg2);
82891     } catch (std::out_of_range& e) {
82892       {
82893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82894       };
82895     } catch (std::exception& e) {
82896       {
82897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82898       };
82899     } catch (Dali::DaliException e) {
82900       {
82901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82902       };
82903     } catch (...) {
82904       {
82905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82906       };
82907     }
82908   }
82909
82910 }
82911
82912
82913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82914   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82915   unsigned int arg2 ;
82916   std::vector< Dali::Actor > *arg3 = 0 ;
82917
82918   arg1 = (Dali::Toolkit::TableView *)jarg1;
82919   arg2 = (unsigned int)jarg2;
82920   arg3 = (std::vector< Dali::Actor > *)jarg3;
82921   if (!arg3) {
82922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82923     return ;
82924   }
82925   {
82926     try {
82927       (arg1)->DeleteColumn(arg2,*arg3);
82928     } catch (std::out_of_range& e) {
82929       {
82930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82931       };
82932     } catch (std::exception& e) {
82933       {
82934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82935       };
82936     } catch (Dali::DaliException e) {
82937       {
82938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82939       };
82940     } catch (...) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82943       };
82944     }
82945   }
82946
82947 }
82948
82949
82950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82951   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82952   unsigned int arg2 ;
82953   unsigned int arg3 ;
82954
82955   arg1 = (Dali::Toolkit::TableView *)jarg1;
82956   arg2 = (unsigned int)jarg2;
82957   arg3 = (unsigned int)jarg3;
82958   {
82959     try {
82960       (arg1)->Resize(arg2,arg3);
82961     } catch (std::out_of_range& e) {
82962       {
82963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82964       };
82965     } catch (std::exception& e) {
82966       {
82967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82968       };
82969     } catch (Dali::DaliException e) {
82970       {
82971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82972       };
82973     } catch (...) {
82974       {
82975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82976       };
82977     }
82978   }
82979
82980 }
82981
82982
82983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82984   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82985   unsigned int arg2 ;
82986   unsigned int arg3 ;
82987   std::vector< Dali::Actor > *arg4 = 0 ;
82988
82989   arg1 = (Dali::Toolkit::TableView *)jarg1;
82990   arg2 = (unsigned int)jarg2;
82991   arg3 = (unsigned int)jarg3;
82992   arg4 = (std::vector< Dali::Actor > *)jarg4;
82993   if (!arg4) {
82994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82995     return ;
82996   }
82997   {
82998     try {
82999       (arg1)->Resize(arg2,arg3,*arg4);
83000     } catch (std::out_of_range& e) {
83001       {
83002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83003       };
83004     } catch (std::exception& e) {
83005       {
83006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83007       };
83008     } catch (Dali::DaliException e) {
83009       {
83010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83011       };
83012     } catch (...) {
83013       {
83014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83015       };
83016     }
83017   }
83018
83019 }
83020
83021
83022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83023   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83024   Dali::Size arg2 ;
83025   Dali::Size *argp2 ;
83026
83027   arg1 = (Dali::Toolkit::TableView *)jarg1;
83028   argp2 = (Dali::Size *)jarg2;
83029   if (!argp2) {
83030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83031     return ;
83032   }
83033   arg2 = *argp2;
83034   {
83035     try {
83036       (arg1)->SetCellPadding(arg2);
83037     } catch (std::out_of_range& e) {
83038       {
83039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83040       };
83041     } catch (std::exception& e) {
83042       {
83043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83044       };
83045     } catch (Dali::DaliException e) {
83046       {
83047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83048       };
83049     } catch (...) {
83050       {
83051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83052       };
83053     }
83054   }
83055
83056 }
83057
83058
83059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83060   void * jresult ;
83061   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83062   Dali::Size result;
83063
83064   arg1 = (Dali::Toolkit::TableView *)jarg1;
83065   {
83066     try {
83067       result = (arg1)->GetCellPadding();
83068     } catch (std::out_of_range& e) {
83069       {
83070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83071       };
83072     } catch (std::exception& e) {
83073       {
83074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83075       };
83076     } catch (Dali::DaliException e) {
83077       {
83078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83079       };
83080     } catch (...) {
83081       {
83082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83083       };
83084     }
83085   }
83086
83087   jresult = new Dali::Size((const Dali::Size &)result);
83088   return jresult;
83089 }
83090
83091
83092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83093   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83094   unsigned int arg2 ;
83095
83096   arg1 = (Dali::Toolkit::TableView *)jarg1;
83097   arg2 = (unsigned int)jarg2;
83098   {
83099     try {
83100       (arg1)->SetFitHeight(arg2);
83101     } catch (std::out_of_range& e) {
83102       {
83103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83104       };
83105     } catch (std::exception& e) {
83106       {
83107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83108       };
83109     } catch (Dali::DaliException e) {
83110       {
83111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83112       };
83113     } catch (...) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83116       };
83117     }
83118   }
83119
83120 }
83121
83122
83123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83124   unsigned int jresult ;
83125   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83126   unsigned int arg2 ;
83127   bool result;
83128
83129   arg1 = (Dali::Toolkit::TableView *)jarg1;
83130   arg2 = (unsigned int)jarg2;
83131   {
83132     try {
83133       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83134     } catch (std::out_of_range& e) {
83135       {
83136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83137       };
83138     } catch (std::exception& e) {
83139       {
83140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83141       };
83142     } catch (Dali::DaliException e) {
83143       {
83144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83145       };
83146     } catch (...) {
83147       {
83148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83149       };
83150     }
83151   }
83152
83153   jresult = result;
83154   return jresult;
83155 }
83156
83157
83158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83159   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83160   unsigned int arg2 ;
83161
83162   arg1 = (Dali::Toolkit::TableView *)jarg1;
83163   arg2 = (unsigned int)jarg2;
83164   {
83165     try {
83166       (arg1)->SetFitWidth(arg2);
83167     } catch (std::out_of_range& e) {
83168       {
83169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83170       };
83171     } catch (std::exception& e) {
83172       {
83173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83174       };
83175     } catch (Dali::DaliException e) {
83176       {
83177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83178       };
83179     } catch (...) {
83180       {
83181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83182       };
83183     }
83184   }
83185
83186 }
83187
83188
83189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83190   unsigned int jresult ;
83191   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83192   unsigned int arg2 ;
83193   bool result;
83194
83195   arg1 = (Dali::Toolkit::TableView *)jarg1;
83196   arg2 = (unsigned int)jarg2;
83197   {
83198     try {
83199       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83200     } catch (std::out_of_range& e) {
83201       {
83202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83203       };
83204     } catch (std::exception& e) {
83205       {
83206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83207       };
83208     } catch (Dali::DaliException e) {
83209       {
83210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83211       };
83212     } catch (...) {
83213       {
83214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83215       };
83216     }
83217   }
83218
83219   jresult = result;
83220   return jresult;
83221 }
83222
83223
83224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83226   unsigned int arg2 ;
83227   float arg3 ;
83228
83229   arg1 = (Dali::Toolkit::TableView *)jarg1;
83230   arg2 = (unsigned int)jarg2;
83231   arg3 = (float)jarg3;
83232   {
83233     try {
83234       (arg1)->SetFixedHeight(arg2,arg3);
83235     } catch (std::out_of_range& e) {
83236       {
83237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83238       };
83239     } catch (std::exception& e) {
83240       {
83241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83242       };
83243     } catch (Dali::DaliException e) {
83244       {
83245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83246       };
83247     } catch (...) {
83248       {
83249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83250       };
83251     }
83252   }
83253
83254 }
83255
83256
83257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83258   float jresult ;
83259   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83260   unsigned int arg2 ;
83261   float result;
83262
83263   arg1 = (Dali::Toolkit::TableView *)jarg1;
83264   arg2 = (unsigned int)jarg2;
83265   {
83266     try {
83267       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83268     } catch (std::out_of_range& e) {
83269       {
83270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83271       };
83272     } catch (std::exception& e) {
83273       {
83274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83275       };
83276     } catch (Dali::DaliException e) {
83277       {
83278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83279       };
83280     } catch (...) {
83281       {
83282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83283       };
83284     }
83285   }
83286
83287   jresult = result;
83288   return jresult;
83289 }
83290
83291
83292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83293   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83294   unsigned int arg2 ;
83295   float arg3 ;
83296
83297   arg1 = (Dali::Toolkit::TableView *)jarg1;
83298   arg2 = (unsigned int)jarg2;
83299   arg3 = (float)jarg3;
83300   {
83301     try {
83302       (arg1)->SetRelativeHeight(arg2,arg3);
83303     } catch (std::out_of_range& e) {
83304       {
83305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83306       };
83307     } catch (std::exception& e) {
83308       {
83309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83310       };
83311     } catch (Dali::DaliException e) {
83312       {
83313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83314       };
83315     } catch (...) {
83316       {
83317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83318       };
83319     }
83320   }
83321
83322 }
83323
83324
83325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83326   float jresult ;
83327   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83328   unsigned int arg2 ;
83329   float result;
83330
83331   arg1 = (Dali::Toolkit::TableView *)jarg1;
83332   arg2 = (unsigned int)jarg2;
83333   {
83334     try {
83335       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83336     } catch (std::out_of_range& e) {
83337       {
83338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83339       };
83340     } catch (std::exception& e) {
83341       {
83342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83343       };
83344     } catch (Dali::DaliException e) {
83345       {
83346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83347       };
83348     } catch (...) {
83349       {
83350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83351       };
83352     }
83353   }
83354
83355   jresult = result;
83356   return jresult;
83357 }
83358
83359
83360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83361   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83362   unsigned int arg2 ;
83363   float arg3 ;
83364
83365   arg1 = (Dali::Toolkit::TableView *)jarg1;
83366   arg2 = (unsigned int)jarg2;
83367   arg3 = (float)jarg3;
83368   {
83369     try {
83370       (arg1)->SetFixedWidth(arg2,arg3);
83371     } catch (std::out_of_range& e) {
83372       {
83373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83374       };
83375     } catch (std::exception& e) {
83376       {
83377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83378       };
83379     } catch (Dali::DaliException e) {
83380       {
83381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83382       };
83383     } catch (...) {
83384       {
83385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83386       };
83387     }
83388   }
83389
83390 }
83391
83392
83393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83394   float jresult ;
83395   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83396   unsigned int arg2 ;
83397   float result;
83398
83399   arg1 = (Dali::Toolkit::TableView *)jarg1;
83400   arg2 = (unsigned int)jarg2;
83401   {
83402     try {
83403       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83404     } catch (std::out_of_range& e) {
83405       {
83406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83407       };
83408     } catch (std::exception& e) {
83409       {
83410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83411       };
83412     } catch (Dali::DaliException e) {
83413       {
83414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83415       };
83416     } catch (...) {
83417       {
83418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83419       };
83420     }
83421   }
83422
83423   jresult = result;
83424   return jresult;
83425 }
83426
83427
83428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83429   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83430   unsigned int arg2 ;
83431   float arg3 ;
83432
83433   arg1 = (Dali::Toolkit::TableView *)jarg1;
83434   arg2 = (unsigned int)jarg2;
83435   arg3 = (float)jarg3;
83436   {
83437     try {
83438       (arg1)->SetRelativeWidth(arg2,arg3);
83439     } catch (std::out_of_range& e) {
83440       {
83441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83442       };
83443     } catch (std::exception& e) {
83444       {
83445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83446       };
83447     } catch (Dali::DaliException e) {
83448       {
83449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83450       };
83451     } catch (...) {
83452       {
83453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83454       };
83455     }
83456   }
83457
83458 }
83459
83460
83461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83462   float jresult ;
83463   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83464   unsigned int arg2 ;
83465   float result;
83466
83467   arg1 = (Dali::Toolkit::TableView *)jarg1;
83468   arg2 = (unsigned int)jarg2;
83469   {
83470     try {
83471       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83472     } catch (std::out_of_range& e) {
83473       {
83474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83475       };
83476     } catch (std::exception& e) {
83477       {
83478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83479       };
83480     } catch (Dali::DaliException e) {
83481       {
83482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83483       };
83484     } catch (...) {
83485       {
83486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83487       };
83488     }
83489   }
83490
83491   jresult = result;
83492   return jresult;
83493 }
83494
83495
83496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83497   unsigned int jresult ;
83498   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83499   unsigned int result;
83500
83501   arg1 = (Dali::Toolkit::TableView *)jarg1;
83502   {
83503     try {
83504       result = (unsigned int)(arg1)->GetRows();
83505     } catch (std::out_of_range& e) {
83506       {
83507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83508       };
83509     } catch (std::exception& e) {
83510       {
83511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83512       };
83513     } catch (Dali::DaliException e) {
83514       {
83515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83516       };
83517     } catch (...) {
83518       {
83519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83520       };
83521     }
83522   }
83523
83524   jresult = result;
83525   return jresult;
83526 }
83527
83528
83529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83530   unsigned int jresult ;
83531   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83532   unsigned int result;
83533
83534   arg1 = (Dali::Toolkit::TableView *)jarg1;
83535   {
83536     try {
83537       result = (unsigned int)(arg1)->GetColumns();
83538     } catch (std::out_of_range& e) {
83539       {
83540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83541       };
83542     } catch (std::exception& e) {
83543       {
83544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83545       };
83546     } catch (Dali::DaliException e) {
83547       {
83548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83549       };
83550     } catch (...) {
83551       {
83552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83553       };
83554     }
83555   }
83556
83557   jresult = result;
83558   return jresult;
83559 }
83560
83561
83562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83563   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83564   Dali::Toolkit::TableView::CellPosition arg2 ;
83565   Dali::HorizontalAlignment::Type arg3 ;
83566   Dali::VerticalAlignment::Type arg4 ;
83567   Dali::Toolkit::TableView::CellPosition *argp2 ;
83568
83569   arg1 = (Dali::Toolkit::TableView *)jarg1;
83570   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83571   if (!argp2) {
83572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83573     return ;
83574   }
83575   arg2 = *argp2;
83576   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83577   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83578   {
83579     try {
83580       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83588       };
83589     } catch (Dali::DaliException e) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83596       };
83597     }
83598   }
83599
83600 }
83601
83602
83603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83604   unsigned int jresult ;
83605   unsigned int result;
83606
83607   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83608   jresult = result;
83609   return jresult;
83610 }
83611
83612
83613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83614   int jresult ;
83615   int result;
83616
83617   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83618   jresult = (int)result;
83619   return jresult;
83620 }
83621
83622
83623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83624   int jresult ;
83625   int result;
83626
83627   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83628   jresult = (int)result;
83629   return jresult;
83630 }
83631
83632
83633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83634   int jresult ;
83635   int result;
83636
83637   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83638   jresult = (int)result;
83639   return jresult;
83640 }
83641
83642
83643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83644   int jresult ;
83645   int result;
83646
83647   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83648   jresult = (int)result;
83649   return jresult;
83650 }
83651
83652
83653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83654   int jresult ;
83655   int result;
83656
83657   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83658   jresult = (int)result;
83659   return jresult;
83660 }
83661
83662
83663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83664   int jresult ;
83665   int result;
83666
83667   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83668   jresult = (int)result;
83669   return jresult;
83670 }
83671
83672
83673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83674   int jresult ;
83675   int result;
83676
83677   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83678   jresult = (int)result;
83679   return jresult;
83680 }
83681
83682
83683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83684   int jresult ;
83685   int result;
83686
83687   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83688   jresult = (int)result;
83689   return jresult;
83690 }
83691
83692
83693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83694   int jresult ;
83695   int result;
83696
83697   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83698   jresult = (int)result;
83699   return jresult;
83700 }
83701
83702
83703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83704   int jresult ;
83705   int result;
83706
83707   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83708   jresult = (int)result;
83709   return jresult;
83710 }
83711
83712
83713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83714   int jresult ;
83715   int result;
83716
83717   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83718   jresult = (int)result;
83719   return jresult;
83720 }
83721
83722
83723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83724   int jresult ;
83725   int result;
83726
83727   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83728   jresult = (int)result;
83729   return jresult;
83730 }
83731
83732
83733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83734   int jresult ;
83735   int result;
83736
83737   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83738   jresult = (int)result;
83739   return jresult;
83740 }
83741
83742
83743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83744   int jresult ;
83745   int result;
83746
83747   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83748   jresult = (int)result;
83749   return jresult;
83750 }
83751
83752
83753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83754   int jresult ;
83755   int result;
83756
83757   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83758   jresult = (int)result;
83759   return jresult;
83760 }
83761
83762
83763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83764   int jresult ;
83765   int result;
83766
83767   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83768   jresult = (int)result;
83769   return jresult;
83770 }
83771
83772
83773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83774   int jresult ;
83775   int result;
83776
83777   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83778   jresult = (int)result;
83779   return jresult;
83780 }
83781
83782
83783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83784   int jresult ;
83785   int result;
83786
83787   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83788   jresult = (int)result;
83789   return jresult;
83790 }
83791
83792
83793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
83794   int jresult ;
83795   int result;
83796
83797   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
83798   jresult = (int)result;
83799   return jresult;
83800 }
83801
83802
83803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
83804   void * jresult ;
83805   Dali::Toolkit::TextLabel::Property *result = 0 ;
83806
83807   {
83808     try {
83809       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
83810     } catch (std::out_of_range& e) {
83811       {
83812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83813       };
83814     } catch (std::exception& e) {
83815       {
83816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83817       };
83818     } catch (Dali::DaliException e) {
83819       {
83820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83821       };
83822     } catch (...) {
83823       {
83824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83825       };
83826     }
83827   }
83828
83829   jresult = (void *)result;
83830   return jresult;
83831 }
83832
83833
83834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
83835   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
83836
83837   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
83838   {
83839     try {
83840       delete arg1;
83841     } catch (std::out_of_range& e) {
83842       {
83843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83844       };
83845     } catch (std::exception& e) {
83846       {
83847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83848       };
83849     } catch (Dali::DaliException e) {
83850       {
83851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83852       };
83853     } catch (...) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83856       };
83857     }
83858   }
83859
83860 }
83861
83862
83863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83864   void * jresult ;
83865   Dali::Toolkit::TextLabel result;
83866
83867   {
83868     try {
83869       result = Dali::Toolkit::TextLabel::New();
83870     } catch (std::out_of_range& e) {
83871       {
83872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83873       };
83874     } catch (std::exception& e) {
83875       {
83876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83877       };
83878     } catch (Dali::DaliException e) {
83879       {
83880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83881       };
83882     } catch (...) {
83883       {
83884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83885       };
83886     }
83887   }
83888
83889   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83890   return jresult;
83891 }
83892
83893
83894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83895   void * jresult ;
83896   std::string *arg1 = 0 ;
83897   Dali::Toolkit::TextLabel result;
83898
83899   if (!jarg1) {
83900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83901     return 0;
83902   }
83903   std::string arg1_str(jarg1);
83904   arg1 = &arg1_str;
83905   {
83906     try {
83907       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83908     } catch (std::out_of_range& e) {
83909       {
83910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83911       };
83912     } catch (std::exception& e) {
83913       {
83914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (Dali::DaliException e) {
83917       {
83918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83919       };
83920     } catch (...) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83923       };
83924     }
83925   }
83926
83927   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83928
83929   //argout typemap for const std::string&
83930
83931   return jresult;
83932 }
83933
83934
83935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83936   void * jresult ;
83937   Dali::Toolkit::TextLabel *result = 0 ;
83938
83939   {
83940     try {
83941       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83942     } catch (std::out_of_range& e) {
83943       {
83944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83945       };
83946     } catch (std::exception& e) {
83947       {
83948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83949       };
83950     } catch (Dali::DaliException e) {
83951       {
83952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83953       };
83954     } catch (...) {
83955       {
83956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83957       };
83958     }
83959   }
83960
83961   jresult = (void *)result;
83962   return jresult;
83963 }
83964
83965
83966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83967   void * jresult ;
83968   Dali::Toolkit::TextLabel *arg1 = 0 ;
83969   Dali::Toolkit::TextLabel *result = 0 ;
83970
83971   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83972   if (!arg1) {
83973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83974     return 0;
83975   }
83976   {
83977     try {
83978       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83979     } catch (std::out_of_range& e) {
83980       {
83981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83982       };
83983     } catch (std::exception& e) {
83984       {
83985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83986       };
83987     } catch (Dali::DaliException e) {
83988       {
83989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83990       };
83991     } catch (...) {
83992       {
83993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83994       };
83995     }
83996   }
83997
83998   jresult = (void *)result;
83999   return jresult;
84000 }
84001
84002
84003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84004   void * jresult ;
84005   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84006   Dali::Toolkit::TextLabel *arg2 = 0 ;
84007   Dali::Toolkit::TextLabel *result = 0 ;
84008
84009   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84010   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84011   if (!arg2) {
84012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84013     return 0;
84014   }
84015   {
84016     try {
84017       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84018     } catch (std::out_of_range& e) {
84019       {
84020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84021       };
84022     } catch (std::exception& e) {
84023       {
84024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84025       };
84026     } catch (Dali::DaliException e) {
84027       {
84028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84029       };
84030     } catch (...) {
84031       {
84032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84033       };
84034     }
84035   }
84036
84037   jresult = (void *)result;
84038   return jresult;
84039 }
84040
84041
84042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84043   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84044
84045   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84046   {
84047     try {
84048       delete arg1;
84049     } catch (std::out_of_range& e) {
84050       {
84051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84052       };
84053     } catch (std::exception& e) {
84054       {
84055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84056       };
84057     } catch (Dali::DaliException e) {
84058       {
84059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84060       };
84061     } catch (...) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84064       };
84065     }
84066   }
84067
84068 }
84069
84070
84071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84072   void * jresult ;
84073   Dali::BaseHandle arg1 ;
84074   Dali::BaseHandle *argp1 ;
84075   Dali::Toolkit::TextLabel result;
84076
84077   argp1 = (Dali::BaseHandle *)jarg1;
84078   if (!argp1) {
84079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84080     return 0;
84081   }
84082   arg1 = *argp1;
84083   {
84084     try {
84085       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84086     } catch (std::out_of_range& e) {
84087       {
84088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84089       };
84090     } catch (std::exception& e) {
84091       {
84092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84093       };
84094     } catch (Dali::DaliException e) {
84095       {
84096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84097       };
84098     } catch (...) {
84099       {
84100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84101       };
84102     }
84103   }
84104
84105   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84106   return jresult;
84107 }
84108
84109
84110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84111   void * jresult ;
84112   Dali::Toolkit::AccessibilityManager *result = 0 ;
84113
84114   {
84115     try {
84116       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84124       };
84125     } catch (Dali::DaliException e) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84132       };
84133     }
84134   }
84135
84136   jresult = (void *)result;
84137   return jresult;
84138 }
84139
84140
84141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84142   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84143
84144   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84145   {
84146     try {
84147       delete arg1;
84148     } catch (std::out_of_range& e) {
84149       {
84150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84151       };
84152     } catch (std::exception& e) {
84153       {
84154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84155       };
84156     } catch (Dali::DaliException e) {
84157       {
84158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84159       };
84160     } catch (...) {
84161       {
84162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84163       };
84164     }
84165   }
84166
84167 }
84168
84169
84170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84171   void * jresult ;
84172   Dali::Toolkit::AccessibilityManager result;
84173
84174   {
84175     try {
84176       result = Dali::Toolkit::AccessibilityManager::Get();
84177     } catch (std::out_of_range& e) {
84178       {
84179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84180       };
84181     } catch (std::exception& e) {
84182       {
84183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84184       };
84185     } catch (Dali::DaliException e) {
84186       {
84187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84188       };
84189     } catch (...) {
84190       {
84191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84192       };
84193     }
84194   }
84195
84196   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84197   return jresult;
84198 }
84199
84200
84201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84202   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84203   Dali::Actor arg2 ;
84204   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84205   std::string *arg4 = 0 ;
84206   Dali::Actor *argp2 ;
84207
84208   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84209   argp2 = (Dali::Actor *)jarg2;
84210   if (!argp2) {
84211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84212     return ;
84213   }
84214   arg2 = *argp2;
84215   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84216   if (!jarg4) {
84217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84218     return ;
84219   }
84220   std::string arg4_str(jarg4);
84221   arg4 = &arg4_str;
84222   {
84223     try {
84224       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84225     } catch (std::out_of_range& e) {
84226       {
84227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84228       };
84229     } catch (std::exception& e) {
84230       {
84231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84232       };
84233     } catch (Dali::DaliException e) {
84234       {
84235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84236       };
84237     } catch (...) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84240       };
84241     }
84242   }
84243
84244
84245   //argout typemap for const std::string&
84246
84247 }
84248
84249
84250 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84251   char * jresult ;
84252   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84253   Dali::Actor arg2 ;
84254   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84255   Dali::Actor *argp2 ;
84256   std::string result;
84257
84258   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84259   argp2 = (Dali::Actor *)jarg2;
84260   if (!argp2) {
84261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84262     return 0;
84263   }
84264   arg2 = *argp2;
84265   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84266   {
84267     try {
84268       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84269     } catch (std::out_of_range& e) {
84270       {
84271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84272       };
84273     } catch (std::exception& e) {
84274       {
84275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84276       };
84277     } catch (Dali::DaliException e) {
84278       {
84279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84280       };
84281     } catch (...) {
84282       {
84283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84284       };
84285     }
84286   }
84287
84288   jresult = SWIG_csharp_string_callback((&result)->c_str());
84289   return jresult;
84290 }
84291
84292
84293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84295   Dali::Actor arg2 ;
84296   unsigned int arg3 ;
84297   Dali::Actor *argp2 ;
84298
84299   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84300   argp2 = (Dali::Actor *)jarg2;
84301   if (!argp2) {
84302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84303     return ;
84304   }
84305   arg2 = *argp2;
84306   arg3 = (unsigned int)jarg3;
84307   {
84308     try {
84309       (arg1)->SetFocusOrder(arg2,arg3);
84310     } catch (std::out_of_range& e) {
84311       {
84312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84313       };
84314     } catch (std::exception& e) {
84315       {
84316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84317       };
84318     } catch (Dali::DaliException e) {
84319       {
84320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84321       };
84322     } catch (...) {
84323       {
84324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84325       };
84326     }
84327   }
84328
84329 }
84330
84331
84332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84333   unsigned int jresult ;
84334   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84335   Dali::Actor arg2 ;
84336   Dali::Actor *argp2 ;
84337   unsigned int result;
84338
84339   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84340   argp2 = (Dali::Actor *)jarg2;
84341   if (!argp2) {
84342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84343     return 0;
84344   }
84345   arg2 = *argp2;
84346   {
84347     try {
84348       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84349     } catch (std::out_of_range& e) {
84350       {
84351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84352       };
84353     } catch (std::exception& e) {
84354       {
84355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84356       };
84357     } catch (Dali::DaliException e) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84360       };
84361     } catch (...) {
84362       {
84363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84364       };
84365     }
84366   }
84367
84368   jresult = result;
84369   return jresult;
84370 }
84371
84372
84373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84374   unsigned int jresult ;
84375   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84376   unsigned int result;
84377
84378   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84379   {
84380     try {
84381       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84382     } catch (std::out_of_range& e) {
84383       {
84384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84385       };
84386     } catch (std::exception& e) {
84387       {
84388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (Dali::DaliException e) {
84391       {
84392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84393       };
84394     } catch (...) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84397       };
84398     }
84399   }
84400
84401   jresult = result;
84402   return jresult;
84403 }
84404
84405
84406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84407   void * jresult ;
84408   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84409   unsigned int arg2 ;
84410   Dali::Actor result;
84411
84412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84413   arg2 = (unsigned int)jarg2;
84414   {
84415     try {
84416       result = (arg1)->GetActorByFocusOrder(arg2);
84417     } catch (std::out_of_range& e) {
84418       {
84419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84420       };
84421     } catch (std::exception& e) {
84422       {
84423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84424       };
84425     } catch (Dali::DaliException e) {
84426       {
84427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84428       };
84429     } catch (...) {
84430       {
84431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84432       };
84433     }
84434   }
84435
84436   jresult = new Dali::Actor((const Dali::Actor &)result);
84437   return jresult;
84438 }
84439
84440
84441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84442   unsigned int jresult ;
84443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84444   Dali::Actor arg2 ;
84445   Dali::Actor *argp2 ;
84446   bool result;
84447
84448   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84449   argp2 = (Dali::Actor *)jarg2;
84450   if (!argp2) {
84451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84452     return 0;
84453   }
84454   arg2 = *argp2;
84455   {
84456     try {
84457       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84458     } catch (std::out_of_range& e) {
84459       {
84460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84461       };
84462     } catch (std::exception& e) {
84463       {
84464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84465       };
84466     } catch (Dali::DaliException e) {
84467       {
84468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84469       };
84470     } catch (...) {
84471       {
84472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84473       };
84474     }
84475   }
84476
84477   jresult = result;
84478   return jresult;
84479 }
84480
84481
84482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84483   void * jresult ;
84484   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84485   Dali::Actor result;
84486
84487   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84488   {
84489     try {
84490       result = (arg1)->GetCurrentFocusActor();
84491     } catch (std::out_of_range& e) {
84492       {
84493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84494       };
84495     } catch (std::exception& e) {
84496       {
84497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84498       };
84499     } catch (Dali::DaliException e) {
84500       {
84501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84502       };
84503     } catch (...) {
84504       {
84505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84506       };
84507     }
84508   }
84509
84510   jresult = new Dali::Actor((const Dali::Actor &)result);
84511   return jresult;
84512 }
84513
84514
84515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84516   void * jresult ;
84517   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84518   Dali::Actor result;
84519
84520   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84521   {
84522     try {
84523       result = (arg1)->GetCurrentFocusGroup();
84524     } catch (std::out_of_range& e) {
84525       {
84526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84527       };
84528     } catch (std::exception& e) {
84529       {
84530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84531       };
84532     } catch (Dali::DaliException e) {
84533       {
84534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84535       };
84536     } catch (...) {
84537       {
84538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84539       };
84540     }
84541   }
84542
84543   jresult = new Dali::Actor((const Dali::Actor &)result);
84544   return jresult;
84545 }
84546
84547
84548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84549   unsigned int jresult ;
84550   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84551   unsigned int result;
84552
84553   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84554   {
84555     try {
84556       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84557     } catch (std::out_of_range& e) {
84558       {
84559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84560       };
84561     } catch (std::exception& e) {
84562       {
84563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84564       };
84565     } catch (Dali::DaliException e) {
84566       {
84567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84568       };
84569     } catch (...) {
84570       {
84571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84572       };
84573     }
84574   }
84575
84576   jresult = result;
84577   return jresult;
84578 }
84579
84580
84581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84582   unsigned int jresult ;
84583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84584   bool result;
84585
84586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84587   {
84588     try {
84589       result = (bool)(arg1)->MoveFocusForward();
84590     } catch (std::out_of_range& e) {
84591       {
84592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84593       };
84594     } catch (std::exception& e) {
84595       {
84596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84597       };
84598     } catch (Dali::DaliException e) {
84599       {
84600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84601       };
84602     } catch (...) {
84603       {
84604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84605       };
84606     }
84607   }
84608
84609   jresult = result;
84610   return jresult;
84611 }
84612
84613
84614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84615   unsigned int jresult ;
84616   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84617   bool result;
84618
84619   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84620   {
84621     try {
84622       result = (bool)(arg1)->MoveFocusBackward();
84623     } catch (std::out_of_range& e) {
84624       {
84625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84626       };
84627     } catch (std::exception& e) {
84628       {
84629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84630       };
84631     } catch (Dali::DaliException e) {
84632       {
84633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84634       };
84635     } catch (...) {
84636       {
84637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84638       };
84639     }
84640   }
84641
84642   jresult = result;
84643   return jresult;
84644 }
84645
84646
84647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84648   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84649
84650   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84651   {
84652     try {
84653       (arg1)->ClearFocus();
84654     } catch (std::out_of_range& e) {
84655       {
84656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84657       };
84658     } catch (std::exception& e) {
84659       {
84660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84661       };
84662     } catch (Dali::DaliException e) {
84663       {
84664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84665       };
84666     } catch (...) {
84667       {
84668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84669       };
84670     }
84671   }
84672
84673 }
84674
84675
84676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84677   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84678
84679   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84680   {
84681     try {
84682       (arg1)->Reset();
84683     } catch (std::out_of_range& e) {
84684       {
84685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84686       };
84687     } catch (std::exception& e) {
84688       {
84689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84690       };
84691     } catch (Dali::DaliException e) {
84692       {
84693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84694       };
84695     } catch (...) {
84696       {
84697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84698       };
84699     }
84700   }
84701
84702 }
84703
84704
84705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84706   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84707   Dali::Actor arg2 ;
84708   bool arg3 ;
84709   Dali::Actor *argp2 ;
84710
84711   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84712   argp2 = (Dali::Actor *)jarg2;
84713   if (!argp2) {
84714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84715     return ;
84716   }
84717   arg2 = *argp2;
84718   arg3 = jarg3 ? true : false;
84719   {
84720     try {
84721       (arg1)->SetFocusGroup(arg2,arg3);
84722     } catch (std::out_of_range& e) {
84723       {
84724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84725       };
84726     } catch (std::exception& e) {
84727       {
84728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84729       };
84730     } catch (Dali::DaliException e) {
84731       {
84732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84733       };
84734     } catch (...) {
84735       {
84736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84737       };
84738     }
84739   }
84740
84741 }
84742
84743
84744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84745   unsigned int jresult ;
84746   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84747   Dali::Actor arg2 ;
84748   Dali::Actor *argp2 ;
84749   bool result;
84750
84751   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84752   argp2 = (Dali::Actor *)jarg2;
84753   if (!argp2) {
84754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84755     return 0;
84756   }
84757   arg2 = *argp2;
84758   {
84759     try {
84760       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84761     } catch (std::out_of_range& e) {
84762       {
84763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84764       };
84765     } catch (std::exception& e) {
84766       {
84767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84768       };
84769     } catch (Dali::DaliException e) {
84770       {
84771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84772       };
84773     } catch (...) {
84774       {
84775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84776       };
84777     }
84778   }
84779
84780   jresult = result;
84781   return jresult;
84782 }
84783
84784
84785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84786   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84787   bool arg2 ;
84788
84789   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84790   arg2 = jarg2 ? true : false;
84791   {
84792     try {
84793       (arg1)->SetGroupMode(arg2);
84794     } catch (std::out_of_range& e) {
84795       {
84796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84797       };
84798     } catch (std::exception& e) {
84799       {
84800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84801       };
84802     } catch (Dali::DaliException e) {
84803       {
84804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84805       };
84806     } catch (...) {
84807       {
84808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84809       };
84810     }
84811   }
84812
84813 }
84814
84815
84816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
84817   unsigned int jresult ;
84818   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84819   bool result;
84820
84821   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84822   {
84823     try {
84824       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
84825     } catch (std::out_of_range& e) {
84826       {
84827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84828       };
84829     } catch (std::exception& e) {
84830       {
84831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84832       };
84833     } catch (Dali::DaliException e) {
84834       {
84835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84836       };
84837     } catch (...) {
84838       {
84839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84840       };
84841     }
84842   }
84843
84844   jresult = result;
84845   return jresult;
84846 }
84847
84848
84849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84851   bool arg2 ;
84852
84853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84854   arg2 = jarg2 ? true : false;
84855   {
84856     try {
84857       (arg1)->SetWrapMode(arg2);
84858     } catch (std::out_of_range& e) {
84859       {
84860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84861       };
84862     } catch (std::exception& e) {
84863       {
84864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84865       };
84866     } catch (Dali::DaliException e) {
84867       {
84868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84869       };
84870     } catch (...) {
84871       {
84872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84873       };
84874     }
84875   }
84876
84877 }
84878
84879
84880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84881   unsigned int jresult ;
84882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84883   bool result;
84884
84885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84886   {
84887     try {
84888       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84889     } catch (std::out_of_range& e) {
84890       {
84891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84892       };
84893     } catch (std::exception& e) {
84894       {
84895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84896       };
84897     } catch (Dali::DaliException e) {
84898       {
84899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84900       };
84901     } catch (...) {
84902       {
84903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84904       };
84905     }
84906   }
84907
84908   jresult = result;
84909   return jresult;
84910 }
84911
84912
84913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84915   Dali::Actor arg2 ;
84916   Dali::Actor *argp2 ;
84917
84918   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84919   argp2 = (Dali::Actor *)jarg2;
84920   if (!argp2) {
84921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84922     return ;
84923   }
84924   arg2 = *argp2;
84925   {
84926     try {
84927       (arg1)->SetFocusIndicatorActor(arg2);
84928     } catch (std::out_of_range& e) {
84929       {
84930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84931       };
84932     } catch (std::exception& e) {
84933       {
84934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84935       };
84936     } catch (Dali::DaliException e) {
84937       {
84938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84939       };
84940     } catch (...) {
84941       {
84942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84943       };
84944     }
84945   }
84946
84947 }
84948
84949
84950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84951   void * jresult ;
84952   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84953   Dali::Actor result;
84954
84955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84956   {
84957     try {
84958       result = (arg1)->GetFocusIndicatorActor();
84959     } catch (std::out_of_range& e) {
84960       {
84961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84962       };
84963     } catch (std::exception& e) {
84964       {
84965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84966       };
84967     } catch (Dali::DaliException e) {
84968       {
84969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84970       };
84971     } catch (...) {
84972       {
84973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84974       };
84975     }
84976   }
84977
84978   jresult = new Dali::Actor((const Dali::Actor &)result);
84979   return jresult;
84980 }
84981
84982
84983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84984   void * jresult ;
84985   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84986   Dali::Actor arg2 ;
84987   Dali::Actor *argp2 ;
84988   Dali::Actor result;
84989
84990   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84991   argp2 = (Dali::Actor *)jarg2;
84992   if (!argp2) {
84993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84994     return 0;
84995   }
84996   arg2 = *argp2;
84997   {
84998     try {
84999       result = (arg1)->GetFocusGroup(arg2);
85000     } catch (std::out_of_range& e) {
85001       {
85002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85003       };
85004     } catch (std::exception& e) {
85005       {
85006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85007       };
85008     } catch (Dali::DaliException e) {
85009       {
85010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85011       };
85012     } catch (...) {
85013       {
85014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85015       };
85016     }
85017   }
85018
85019   jresult = new Dali::Actor((const Dali::Actor &)result);
85020   return jresult;
85021 }
85022
85023
85024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85025   void * jresult ;
85026   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85027   Dali::Vector2 result;
85028
85029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85030   {
85031     try {
85032       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85033     } catch (std::out_of_range& e) {
85034       {
85035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85036       };
85037     } catch (std::exception& e) {
85038       {
85039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85040       };
85041     } catch (Dali::DaliException e) {
85042       {
85043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85044       };
85045     } catch (...) {
85046       {
85047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85048       };
85049     }
85050   }
85051
85052   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85053   return jresult;
85054 }
85055
85056
85057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85058   void * jresult ;
85059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85060   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85061
85062   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85063   {
85064     try {
85065       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85066     } catch (std::out_of_range& e) {
85067       {
85068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85069       };
85070     } catch (std::exception& e) {
85071       {
85072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85073       };
85074     } catch (Dali::DaliException e) {
85075       {
85076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85077       };
85078     } catch (...) {
85079       {
85080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85081       };
85082     }
85083   }
85084
85085   jresult = (void *)result;
85086   return jresult;
85087 }
85088
85089
85090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85091   void * jresult ;
85092   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85093   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85094
85095   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85096   {
85097     try {
85098       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85099     } catch (std::out_of_range& e) {
85100       {
85101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85102       };
85103     } catch (std::exception& e) {
85104       {
85105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85106       };
85107     } catch (Dali::DaliException e) {
85108       {
85109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85110       };
85111     } catch (...) {
85112       {
85113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85114       };
85115     }
85116   }
85117
85118   jresult = (void *)result;
85119   return jresult;
85120 }
85121
85122
85123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85124   void * jresult ;
85125   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85126   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85127
85128   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85129   {
85130     try {
85131       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85132     } catch (std::out_of_range& e) {
85133       {
85134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85135       };
85136     } catch (std::exception& e) {
85137       {
85138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85139       };
85140     } catch (Dali::DaliException e) {
85141       {
85142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85143       };
85144     } catch (...) {
85145       {
85146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85147       };
85148     }
85149   }
85150
85151   jresult = (void *)result;
85152   return jresult;
85153 }
85154
85155
85156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85157   void * jresult ;
85158   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85159   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85160
85161   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85162   {
85163     try {
85164       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85165     } catch (std::out_of_range& e) {
85166       {
85167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85168       };
85169     } catch (std::exception& e) {
85170       {
85171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85172       };
85173     } catch (Dali::DaliException e) {
85174       {
85175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85176       };
85177     } catch (...) {
85178       {
85179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85180       };
85181     }
85182   }
85183
85184   jresult = (void *)result;
85185   return jresult;
85186 }
85187
85188
85189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85190   void * jresult ;
85191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85192   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85193
85194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85195   {
85196     try {
85197       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85198     } catch (std::out_of_range& e) {
85199       {
85200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85201       };
85202     } catch (std::exception& e) {
85203       {
85204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85205       };
85206     } catch (Dali::DaliException e) {
85207       {
85208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85209       };
85210     } catch (...) {
85211       {
85212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85213       };
85214     }
85215   }
85216
85217   jresult = (void *)result;
85218   return jresult;
85219 }
85220
85221
85222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85223   void * jresult ;
85224   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85225   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85226
85227   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85228   {
85229     try {
85230       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85231     } catch (std::out_of_range& e) {
85232       {
85233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85234       };
85235     } catch (std::exception& e) {
85236       {
85237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85238       };
85239     } catch (Dali::DaliException e) {
85240       {
85241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85242       };
85243     } catch (...) {
85244       {
85245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85246       };
85247     }
85248   }
85249
85250   jresult = (void *)result;
85251   return jresult;
85252 }
85253
85254
85255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85256   void * jresult ;
85257   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85258   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85259
85260   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85261   {
85262     try {
85263       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85264     } catch (std::out_of_range& e) {
85265       {
85266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85267       };
85268     } catch (std::exception& e) {
85269       {
85270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85271       };
85272     } catch (Dali::DaliException e) {
85273       {
85274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85275       };
85276     } catch (...) {
85277       {
85278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85279       };
85280     }
85281   }
85282
85283   jresult = (void *)result;
85284   return jresult;
85285 }
85286
85287
85288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85289   void * jresult ;
85290   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85291   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85292
85293   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85294   {
85295     try {
85296       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85297     } catch (std::out_of_range& e) {
85298       {
85299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85300       };
85301     } catch (std::exception& e) {
85302       {
85303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85304       };
85305     } catch (Dali::DaliException e) {
85306       {
85307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85308       };
85309     } catch (...) {
85310       {
85311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85312       };
85313     }
85314   }
85315
85316   jresult = (void *)result;
85317   return jresult;
85318 }
85319
85320
85321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85322   void * jresult ;
85323   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85324   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85325
85326   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85327   {
85328     try {
85329       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85330     } catch (std::out_of_range& e) {
85331       {
85332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85333       };
85334     } catch (std::exception& e) {
85335       {
85336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85337       };
85338     } catch (Dali::DaliException e) {
85339       {
85340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85341       };
85342     } catch (...) {
85343       {
85344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85345       };
85346     }
85347   }
85348
85349   jresult = (void *)result;
85350   return jresult;
85351 }
85352
85353
85354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85355   void * jresult ;
85356   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85357   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85358
85359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85360   {
85361     try {
85362       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85363     } catch (std::out_of_range& e) {
85364       {
85365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85366       };
85367     } catch (std::exception& e) {
85368       {
85369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85370       };
85371     } catch (Dali::DaliException e) {
85372       {
85373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85374       };
85375     } catch (...) {
85376       {
85377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85378       };
85379     }
85380   }
85381
85382   jresult = (void *)result;
85383   return jresult;
85384 }
85385
85386
85387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85388   void * jresult ;
85389   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85390   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85391
85392   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85393   {
85394     try {
85395       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85396     } catch (std::out_of_range& e) {
85397       {
85398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85399       };
85400     } catch (std::exception& e) {
85401       {
85402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85403       };
85404     } catch (Dali::DaliException e) {
85405       {
85406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85407       };
85408     } catch (...) {
85409       {
85410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85411       };
85412     }
85413   }
85414
85415   jresult = (void *)result;
85416   return jresult;
85417 }
85418
85419
85420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85421   void * jresult ;
85422   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85423   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85424
85425   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85426   {
85427     try {
85428       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85429     } catch (std::out_of_range& e) {
85430       {
85431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85432       };
85433     } catch (std::exception& e) {
85434       {
85435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85436       };
85437     } catch (Dali::DaliException e) {
85438       {
85439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85440       };
85441     } catch (...) {
85442       {
85443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85444       };
85445     }
85446   }
85447
85448   jresult = (void *)result;
85449   return jresult;
85450 }
85451
85452
85453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85454   void * jresult ;
85455   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85456   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85457
85458   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85459   {
85460     try {
85461       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85462     } catch (std::out_of_range& e) {
85463       {
85464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85465       };
85466     } catch (std::exception& e) {
85467       {
85468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85469       };
85470     } catch (Dali::DaliException e) {
85471       {
85472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85473       };
85474     } catch (...) {
85475       {
85476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85477       };
85478     }
85479   }
85480
85481   jresult = (void *)result;
85482   return jresult;
85483 }
85484
85485
85486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85487   void * jresult ;
85488   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85489   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85490
85491   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85492   {
85493     try {
85494       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85495     } catch (std::out_of_range& e) {
85496       {
85497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85498       };
85499     } catch (std::exception& e) {
85500       {
85501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85502       };
85503     } catch (Dali::DaliException e) {
85504       {
85505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85506       };
85507     } catch (...) {
85508       {
85509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85510       };
85511     }
85512   }
85513
85514   jresult = (void *)result;
85515   return jresult;
85516 }
85517
85518
85519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85520   void * jresult ;
85521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85522   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85523
85524   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85525   {
85526     try {
85527       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85528     } catch (std::out_of_range& e) {
85529       {
85530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85531       };
85532     } catch (std::exception& e) {
85533       {
85534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85535       };
85536     } catch (Dali::DaliException e) {
85537       {
85538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85539       };
85540     } catch (...) {
85541       {
85542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85543       };
85544     }
85545   }
85546
85547   jresult = (void *)result;
85548   return jresult;
85549 }
85550
85551
85552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85553   void * jresult ;
85554   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85555   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85556
85557   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85558   {
85559     try {
85560       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85561     } catch (std::out_of_range& e) {
85562       {
85563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85564       };
85565     } catch (std::exception& e) {
85566       {
85567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85568       };
85569     } catch (Dali::DaliException e) {
85570       {
85571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85572       };
85573     } catch (...) {
85574       {
85575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85576       };
85577     }
85578   }
85579
85580   jresult = (void *)result;
85581   return jresult;
85582 }
85583
85584
85585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85586   void * jresult ;
85587   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85588   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85589
85590   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85591   {
85592     try {
85593       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85594     } catch (std::out_of_range& e) {
85595       {
85596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85597       };
85598     } catch (std::exception& e) {
85599       {
85600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85601       };
85602     } catch (Dali::DaliException e) {
85603       {
85604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85605       };
85606     } catch (...) {
85607       {
85608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85609       };
85610     }
85611   }
85612
85613   jresult = (void *)result;
85614   return jresult;
85615 }
85616
85617
85618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85619   void * jresult ;
85620   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85621   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85622
85623   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85624   {
85625     try {
85626       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85627     } catch (std::out_of_range& e) {
85628       {
85629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85630       };
85631     } catch (std::exception& e) {
85632       {
85633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85634       };
85635     } catch (Dali::DaliException e) {
85636       {
85637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85638       };
85639     } catch (...) {
85640       {
85641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85642       };
85643     }
85644   }
85645
85646   jresult = (void *)result;
85647   return jresult;
85648 }
85649
85650
85651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85652   void * jresult ;
85653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85654   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85655
85656   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85657   {
85658     try {
85659       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85660     } catch (std::out_of_range& e) {
85661       {
85662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85663       };
85664     } catch (std::exception& e) {
85665       {
85666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85667       };
85668     } catch (Dali::DaliException e) {
85669       {
85670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85671       };
85672     } catch (...) {
85673       {
85674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85675       };
85676     }
85677   }
85678
85679   jresult = (void *)result;
85680   return jresult;
85681 }
85682
85683
85684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85685   void * jresult ;
85686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85687   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85688
85689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85690   {
85691     try {
85692       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85693     } catch (std::out_of_range& e) {
85694       {
85695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85696       };
85697     } catch (std::exception& e) {
85698       {
85699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85700       };
85701     } catch (Dali::DaliException e) {
85702       {
85703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85704       };
85705     } catch (...) {
85706       {
85707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85708       };
85709     }
85710   }
85711
85712   jresult = (void *)result;
85713   return jresult;
85714 }
85715
85716
85717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85718   void * jresult ;
85719   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85720   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85721
85722   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85723   {
85724     try {
85725       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85726     } catch (std::out_of_range& e) {
85727       {
85728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85729       };
85730     } catch (std::exception& e) {
85731       {
85732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85733       };
85734     } catch (Dali::DaliException e) {
85735       {
85736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85737       };
85738     } catch (...) {
85739       {
85740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85741       };
85742     }
85743   }
85744
85745   jresult = (void *)result;
85746   return jresult;
85747 }
85748
85749
85750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85751   void * jresult ;
85752   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85753   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85754
85755   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85756   {
85757     try {
85758       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85759     } catch (std::out_of_range& e) {
85760       {
85761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85762       };
85763     } catch (std::exception& e) {
85764       {
85765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85766       };
85767     } catch (Dali::DaliException e) {
85768       {
85769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85770       };
85771     } catch (...) {
85772       {
85773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85774       };
85775     }
85776   }
85777
85778   jresult = (void *)result;
85779   return jresult;
85780 }
85781
85782
85783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85784   void * jresult ;
85785   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85786   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85787
85788   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85789   {
85790     try {
85791       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
85792     } catch (std::out_of_range& e) {
85793       {
85794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85795       };
85796     } catch (std::exception& e) {
85797       {
85798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85799       };
85800     } catch (Dali::DaliException e) {
85801       {
85802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85803       };
85804     } catch (...) {
85805       {
85806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85807       };
85808     }
85809   }
85810
85811   jresult = (void *)result;
85812   return jresult;
85813 }
85814
85815
85816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
85817   void * jresult ;
85818   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85819   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85820
85821   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85822   {
85823     try {
85824       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
85825     } catch (std::out_of_range& e) {
85826       {
85827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85828       };
85829     } catch (std::exception& e) {
85830       {
85831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85832       };
85833     } catch (Dali::DaliException e) {
85834       {
85835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85836       };
85837     } catch (...) {
85838       {
85839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85840       };
85841     }
85842   }
85843
85844   jresult = (void *)result;
85845   return jresult;
85846 }
85847
85848
85849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85850   void * jresult ;
85851   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85852   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85853
85854   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85855   {
85856     try {
85857       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85858     } catch (std::out_of_range& e) {
85859       {
85860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85861       };
85862     } catch (std::exception& e) {
85863       {
85864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85865       };
85866     } catch (Dali::DaliException e) {
85867       {
85868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85869       };
85870     } catch (...) {
85871       {
85872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85873       };
85874     }
85875   }
85876
85877   jresult = (void *)result;
85878   return jresult;
85879 }
85880
85881
85882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85883   void * jresult ;
85884   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85885   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85886
85887   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85888   {
85889     try {
85890       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85891     } catch (std::out_of_range& e) {
85892       {
85893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85894       };
85895     } catch (std::exception& e) {
85896       {
85897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85898       };
85899     } catch (Dali::DaliException e) {
85900       {
85901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85902       };
85903     } catch (...) {
85904       {
85905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85906       };
85907     }
85908   }
85909
85910   jresult = (void *)result;
85911   return jresult;
85912 }
85913
85914
85915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85916   void * jresult ;
85917   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85918   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85919
85920   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85921   {
85922     try {
85923       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85924     } catch (std::out_of_range& e) {
85925       {
85926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85927       };
85928     } catch (std::exception& e) {
85929       {
85930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85931       };
85932     } catch (Dali::DaliException e) {
85933       {
85934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85935       };
85936     } catch (...) {
85937       {
85938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85939       };
85940     }
85941   }
85942
85943   jresult = (void *)result;
85944   return jresult;
85945 }
85946
85947
85948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85949   void * jresult ;
85950   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85951   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85952
85953   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85954   {
85955     try {
85956       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85957     } catch (std::out_of_range& e) {
85958       {
85959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85960       };
85961     } catch (std::exception& e) {
85962       {
85963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85964       };
85965     } catch (Dali::DaliException e) {
85966       {
85967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85968       };
85969     } catch (...) {
85970       {
85971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85972       };
85973     }
85974   }
85975
85976   jresult = (void *)result;
85977   return jresult;
85978 }
85979
85980
85981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85982   void * jresult ;
85983   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85984   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85985
85986   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85987   {
85988     try {
85989       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85990     } catch (std::out_of_range& e) {
85991       {
85992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85993       };
85994     } catch (std::exception& e) {
85995       {
85996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85997       };
85998     } catch (Dali::DaliException e) {
85999       {
86000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86001       };
86002     } catch (...) {
86003       {
86004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86005       };
86006     }
86007   }
86008
86009   jresult = (void *)result;
86010   return jresult;
86011 }
86012
86013
86014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86015   void * jresult ;
86016   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86017   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86018
86019   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86020   {
86021     try {
86022       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86023     } catch (std::out_of_range& e) {
86024       {
86025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86026       };
86027     } catch (std::exception& e) {
86028       {
86029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86030       };
86031     } catch (Dali::DaliException e) {
86032       {
86033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86034       };
86035     } catch (...) {
86036       {
86037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86038       };
86039     }
86040   }
86041
86042   jresult = (void *)result;
86043   return jresult;
86044 }
86045
86046
86047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86048   void * jresult ;
86049   Dali::Toolkit::StyleManager *result = 0 ;
86050
86051   {
86052     try {
86053       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86054     } catch (std::out_of_range& e) {
86055       {
86056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86057       };
86058     } catch (std::exception& e) {
86059       {
86060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86061       };
86062     } catch (Dali::DaliException e) {
86063       {
86064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86065       };
86066     } catch (...) {
86067       {
86068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86069       };
86070     }
86071   }
86072
86073   jresult = (void *)result;
86074   return jresult;
86075 }
86076
86077
86078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86079   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86080
86081   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86082   {
86083     try {
86084       delete arg1;
86085     } catch (std::out_of_range& e) {
86086       {
86087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86088       };
86089     } catch (std::exception& e) {
86090       {
86091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86092       };
86093     } catch (Dali::DaliException e) {
86094       {
86095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86096       };
86097     } catch (...) {
86098       {
86099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86100       };
86101     }
86102   }
86103
86104 }
86105
86106
86107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86108   void * jresult ;
86109   Dali::Toolkit::StyleManager result;
86110
86111   {
86112     try {
86113       result = Dali::Toolkit::StyleManager::Get();
86114     } catch (std::out_of_range& e) {
86115       {
86116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86117       };
86118     } catch (std::exception& e) {
86119       {
86120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86121       };
86122     } catch (Dali::DaliException e) {
86123       {
86124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86125       };
86126     } catch (...) {
86127       {
86128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86129       };
86130     }
86131   }
86132
86133   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86134   return jresult;
86135 }
86136
86137
86138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86139   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86140   std::string *arg2 = 0 ;
86141
86142   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86143   if (!jarg2) {
86144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86145     return ;
86146   }
86147   std::string arg2_str(jarg2);
86148   arg2 = &arg2_str;
86149   {
86150     try {
86151       (arg1)->ApplyTheme((std::string const &)*arg2);
86152     } catch (std::out_of_range& e) {
86153       {
86154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86155       };
86156     } catch (std::exception& e) {
86157       {
86158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86159       };
86160     } catch (Dali::DaliException e) {
86161       {
86162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86163       };
86164     } catch (...) {
86165       {
86166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86167       };
86168     }
86169   }
86170
86171
86172   //argout typemap for const std::string&
86173
86174 }
86175
86176
86177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86178   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86179
86180   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86181   {
86182     try {
86183       (arg1)->ApplyDefaultTheme();
86184     } catch (std::out_of_range& e) {
86185       {
86186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86187       };
86188     } catch (std::exception& e) {
86189       {
86190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86191       };
86192     } catch (Dali::DaliException e) {
86193       {
86194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86195       };
86196     } catch (...) {
86197       {
86198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86199       };
86200     }
86201   }
86202
86203 }
86204
86205
86206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86207   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86208   std::string *arg2 = 0 ;
86209   Dali::Property::Value *arg3 = 0 ;
86210
86211   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86212   if (!jarg2) {
86213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86214     return ;
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 const & type is null", 0);
86221     return ;
86222   }
86223   {
86224     try {
86225       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86226     } catch (std::out_of_range& e) {
86227       {
86228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86229       };
86230     } catch (std::exception& e) {
86231       {
86232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86233       };
86234     } catch (Dali::DaliException e) {
86235       {
86236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86237       };
86238     } catch (...) {
86239       {
86240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86241       };
86242     }
86243   }
86244
86245
86246   //argout typemap for const std::string&
86247
86248 }
86249
86250
86251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86252   unsigned int jresult ;
86253   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86254   std::string *arg2 = 0 ;
86255   Dali::Property::Value *arg3 = 0 ;
86256   bool result;
86257
86258   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86259   if (!jarg2) {
86260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86261     return 0;
86262   }
86263   std::string arg2_str(jarg2);
86264   arg2 = &arg2_str;
86265   arg3 = (Dali::Property::Value *)jarg3;
86266   if (!arg3) {
86267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86268     return 0;
86269   }
86270   {
86271     try {
86272       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86273     } catch (std::out_of_range& e) {
86274       {
86275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86276       };
86277     } catch (std::exception& e) {
86278       {
86279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86280       };
86281     } catch (Dali::DaliException e) {
86282       {
86283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86284       };
86285     } catch (...) {
86286       {
86287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86288       };
86289     }
86290   }
86291
86292   jresult = result;
86293
86294   //argout typemap for const std::string&
86295
86296   return jresult;
86297 }
86298
86299
86300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86301   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86302   Dali::Toolkit::Control arg2 ;
86303   std::string *arg3 = 0 ;
86304   std::string *arg4 = 0 ;
86305   Dali::Toolkit::Control *argp2 ;
86306
86307   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86308   argp2 = (Dali::Toolkit::Control *)jarg2;
86309   if (!argp2) {
86310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86311     return ;
86312   }
86313   arg2 = *argp2;
86314   if (!jarg3) {
86315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86316     return ;
86317   }
86318   std::string arg3_str(jarg3);
86319   arg3 = &arg3_str;
86320   if (!jarg4) {
86321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86322     return ;
86323   }
86324   std::string arg4_str(jarg4);
86325   arg4 = &arg4_str;
86326   {
86327     try {
86328       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86329     } catch (std::out_of_range& e) {
86330       {
86331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86332       };
86333     } catch (std::exception& e) {
86334       {
86335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86336       };
86337     } catch (Dali::DaliException e) {
86338       {
86339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86340       };
86341     } catch (...) {
86342       {
86343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86344       };
86345     }
86346   }
86347
86348
86349   //argout typemap for const std::string&
86350
86351
86352   //argout typemap for const std::string&
86353
86354 }
86355
86356
86357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86358   void * jresult ;
86359   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86360   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86361
86362   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86363   {
86364     try {
86365       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86366     } catch (std::out_of_range& e) {
86367       {
86368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86369       };
86370     } catch (std::exception& e) {
86371       {
86372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86373       };
86374     } catch (Dali::DaliException e) {
86375       {
86376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86377       };
86378     } catch (...) {
86379       {
86380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86381       };
86382     }
86383   }
86384
86385   jresult = (void *)result;
86386   return jresult;
86387 }
86388
86389
86390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86391   int jresult ;
86392   int result;
86393
86394   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86395   jresult = (int)result;
86396   return jresult;
86397 }
86398
86399
86400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86401   int jresult ;
86402   int result;
86403
86404   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86405   jresult = (int)result;
86406   return jresult;
86407 }
86408
86409
86410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86411   int jresult ;
86412   int result;
86413
86414   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86415   jresult = (int)result;
86416   return jresult;
86417 }
86418
86419
86420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86421   int jresult ;
86422   int result;
86423
86424   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86425   jresult = (int)result;
86426   return jresult;
86427 }
86428
86429
86430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86431   int jresult ;
86432   int result;
86433
86434   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86435   jresult = (int)result;
86436   return jresult;
86437 }
86438
86439
86440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86441   int jresult ;
86442   int result;
86443
86444   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86445   jresult = (int)result;
86446   return jresult;
86447 }
86448
86449
86450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86451   int jresult ;
86452   int result;
86453
86454   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86455   jresult = (int)result;
86456   return jresult;
86457 }
86458
86459
86460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86461   int jresult ;
86462   int result;
86463
86464   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86465   jresult = (int)result;
86466   return jresult;
86467 }
86468
86469
86470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86471   int jresult ;
86472   int result;
86473
86474   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86475   jresult = (int)result;
86476   return jresult;
86477 }
86478
86479
86480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86481   int jresult ;
86482   int result;
86483
86484   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86485   jresult = (int)result;
86486   return jresult;
86487 }
86488
86489
86490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86491   int jresult ;
86492   int result;
86493
86494   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86495   jresult = (int)result;
86496   return jresult;
86497 }
86498
86499
86500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86501   int jresult ;
86502   int result;
86503
86504   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86505   jresult = (int)result;
86506   return jresult;
86507 }
86508
86509
86510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86511   int jresult ;
86512   int result;
86513
86514   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86515   jresult = (int)result;
86516   return jresult;
86517 }
86518
86519
86520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86521   int jresult ;
86522   int result;
86523
86524   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86525   jresult = (int)result;
86526   return jresult;
86527 }
86528
86529
86530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86531   int jresult ;
86532   int result;
86533
86534   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86535   jresult = (int)result;
86536   return jresult;
86537 }
86538
86539
86540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86541   void * jresult ;
86542   Dali::Toolkit::Slider::Property *result = 0 ;
86543
86544   {
86545     try {
86546       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86547     } catch (std::out_of_range& e) {
86548       {
86549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86550       };
86551     } catch (std::exception& e) {
86552       {
86553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86554       };
86555     } catch (Dali::DaliException e) {
86556       {
86557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86558       };
86559     } catch (...) {
86560       {
86561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86562       };
86563     }
86564   }
86565
86566   jresult = (void *)result;
86567   return jresult;
86568 }
86569
86570
86571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86572   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86573
86574   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86575   {
86576     try {
86577       delete arg1;
86578     } catch (std::out_of_range& e) {
86579       {
86580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86581       };
86582     } catch (std::exception& e) {
86583       {
86584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86585       };
86586     } catch (Dali::DaliException e) {
86587       {
86588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86589       };
86590     } catch (...) {
86591       {
86592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86593       };
86594     }
86595   }
86596
86597 }
86598
86599
86600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86601   void * jresult ;
86602   Dali::Toolkit::Slider result;
86603
86604   {
86605     try {
86606       result = Dali::Toolkit::Slider::New();
86607     } catch (std::out_of_range& e) {
86608       {
86609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86610       };
86611     } catch (std::exception& e) {
86612       {
86613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86614       };
86615     } catch (Dali::DaliException e) {
86616       {
86617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86618       };
86619     } catch (...) {
86620       {
86621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86622       };
86623     }
86624   }
86625
86626   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86627   return jresult;
86628 }
86629
86630
86631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86632   void * jresult ;
86633   Dali::Toolkit::Slider *result = 0 ;
86634
86635   {
86636     try {
86637       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86638     } catch (std::out_of_range& e) {
86639       {
86640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86641       };
86642     } catch (std::exception& e) {
86643       {
86644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86645       };
86646     } catch (Dali::DaliException e) {
86647       {
86648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86649       };
86650     } catch (...) {
86651       {
86652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86653       };
86654     }
86655   }
86656
86657   jresult = (void *)result;
86658   return jresult;
86659 }
86660
86661
86662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86663   void * jresult ;
86664   Dali::Toolkit::Slider *arg1 = 0 ;
86665   Dali::Toolkit::Slider *result = 0 ;
86666
86667   arg1 = (Dali::Toolkit::Slider *)jarg1;
86668   if (!arg1) {
86669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86670     return 0;
86671   }
86672   {
86673     try {
86674       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86675     } catch (std::out_of_range& e) {
86676       {
86677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86678       };
86679     } catch (std::exception& e) {
86680       {
86681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86682       };
86683     } catch (Dali::DaliException e) {
86684       {
86685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86686       };
86687     } catch (...) {
86688       {
86689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86690       };
86691     }
86692   }
86693
86694   jresult = (void *)result;
86695   return jresult;
86696 }
86697
86698
86699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86700   void * jresult ;
86701   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86702   Dali::Toolkit::Slider *arg2 = 0 ;
86703   Dali::Toolkit::Slider *result = 0 ;
86704
86705   arg1 = (Dali::Toolkit::Slider *)jarg1;
86706   arg2 = (Dali::Toolkit::Slider *)jarg2;
86707   if (!arg2) {
86708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86709     return 0;
86710   }
86711   {
86712     try {
86713       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86714     } catch (std::out_of_range& e) {
86715       {
86716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86717       };
86718     } catch (std::exception& e) {
86719       {
86720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86721       };
86722     } catch (Dali::DaliException e) {
86723       {
86724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86725       };
86726     } catch (...) {
86727       {
86728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86729       };
86730     }
86731   }
86732
86733   jresult = (void *)result;
86734   return jresult;
86735 }
86736
86737
86738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86739   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86740
86741   arg1 = (Dali::Toolkit::Slider *)jarg1;
86742   {
86743     try {
86744       delete arg1;
86745     } catch (std::out_of_range& e) {
86746       {
86747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86748       };
86749     } catch (std::exception& e) {
86750       {
86751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86752       };
86753     } catch (Dali::DaliException e) {
86754       {
86755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86756       };
86757     } catch (...) {
86758       {
86759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86760       };
86761     }
86762   }
86763
86764 }
86765
86766
86767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86768   void * jresult ;
86769   Dali::BaseHandle arg1 ;
86770   Dali::BaseHandle *argp1 ;
86771   Dali::Toolkit::Slider result;
86772
86773   argp1 = (Dali::BaseHandle *)jarg1;
86774   if (!argp1) {
86775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86776     return 0;
86777   }
86778   arg1 = *argp1;
86779   {
86780     try {
86781       result = Dali::Toolkit::Slider::DownCast(arg1);
86782     } catch (std::out_of_range& e) {
86783       {
86784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86785       };
86786     } catch (std::exception& e) {
86787       {
86788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86789       };
86790     } catch (Dali::DaliException e) {
86791       {
86792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86793       };
86794     } catch (...) {
86795       {
86796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86797       };
86798     }
86799   }
86800
86801   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86802   return jresult;
86803 }
86804
86805
86806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
86807   void * jresult ;
86808   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86809   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86810
86811   arg1 = (Dali::Toolkit::Slider *)jarg1;
86812   {
86813     try {
86814       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
86815     } catch (std::out_of_range& e) {
86816       {
86817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86818       };
86819     } catch (std::exception& e) {
86820       {
86821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86822       };
86823     } catch (Dali::DaliException e) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86826       };
86827     } catch (...) {
86828       {
86829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86830       };
86831     }
86832   }
86833
86834   jresult = (void *)result;
86835   return jresult;
86836 }
86837
86838
86839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
86840   void * jresult ;
86841   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86842   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86843
86844   arg1 = (Dali::Toolkit::Slider *)jarg1;
86845   {
86846     try {
86847       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
86848     } catch (std::out_of_range& e) {
86849       {
86850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86851       };
86852     } catch (std::exception& e) {
86853       {
86854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86855       };
86856     } catch (Dali::DaliException e) {
86857       {
86858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86859       };
86860     } catch (...) {
86861       {
86862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86863       };
86864     }
86865   }
86866
86867   jresult = (void *)result;
86868   return jresult;
86869 }
86870
86871
86872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86873   void * jresult ;
86874   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86875   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86876
86877   arg1 = (Dali::Toolkit::Slider *)jarg1;
86878   {
86879     try {
86880       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86881     } catch (std::out_of_range& e) {
86882       {
86883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86884       };
86885     } catch (std::exception& e) {
86886       {
86887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (Dali::DaliException e) {
86890       {
86891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86892       };
86893     } catch (...) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86896       };
86897     }
86898   }
86899
86900   jresult = (void *)result;
86901   return jresult;
86902 }
86903
86904
86905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86906   int jresult ;
86907   int result;
86908
86909   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86910   jresult = (int)result;
86911   return jresult;
86912 }
86913
86914
86915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86916   int jresult ;
86917   int result;
86918
86919   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86920   jresult = (int)result;
86921   return jresult;
86922 }
86923
86924
86925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86926   int jresult ;
86927   int result;
86928
86929   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86930   jresult = (int)result;
86931   return jresult;
86932 }
86933
86934
86935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86936   int jresult ;
86937   int result;
86938
86939   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86940   jresult = (int)result;
86941   return jresult;
86942 }
86943
86944
86945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86946   int result;
86947
86948   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86949
86950   return result;
86951 }
86952
86953
86954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86955   void * jresult ;
86956   Dali::Toolkit::VideoView::Property *result = 0 ;
86957
86958   {
86959     try {
86960       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86961     } catch (std::out_of_range& e) {
86962       {
86963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86964       };
86965     } catch (std::exception& e) {
86966       {
86967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86968       };
86969     } catch (Dali::DaliException e) {
86970       {
86971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86972       };
86973     } catch (...) {
86974       {
86975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86976       };
86977     }
86978   }
86979
86980   jresult = (void *)result;
86981   return jresult;
86982 }
86983
86984
86985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86986   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86987
86988   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86989   {
86990     try {
86991       delete arg1;
86992     } catch (std::out_of_range& e) {
86993       {
86994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86995       };
86996     } catch (std::exception& e) {
86997       {
86998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86999       };
87000     } catch (Dali::DaliException e) {
87001       {
87002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87003       };
87004     } catch (...) {
87005       {
87006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87007       };
87008     }
87009   }
87010
87011 }
87012
87013
87014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87015   void * jresult ;
87016   Dali::Toolkit::VideoView result;
87017
87018   {
87019     try {
87020       result = Dali::Toolkit::VideoView::New();
87021     } catch (std::out_of_range& e) {
87022       {
87023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87024       };
87025     } catch (std::exception& e) {
87026       {
87027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87028       };
87029     } catch (Dali::DaliException e) {
87030       {
87031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87032       };
87033     } catch (...) {
87034       {
87035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87036       };
87037     }
87038   }
87039
87040   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87041   return jresult;
87042 }
87043
87044
87045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87046   void * jresult ;
87047   std::string *arg1 = 0 ;
87048   Dali::Toolkit::VideoView result;
87049
87050   if (!jarg1) {
87051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87052     return 0;
87053   }
87054   std::string arg1_str(jarg1);
87055   arg1 = &arg1_str;
87056   {
87057     try {
87058       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87059     } catch (std::out_of_range& e) {
87060       {
87061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87062       };
87063     } catch (std::exception& e) {
87064       {
87065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87066       };
87067     } catch (Dali::DaliException e) {
87068       {
87069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87070       };
87071     } catch (...) {
87072       {
87073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87074       };
87075     }
87076   }
87077
87078   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87079
87080   //argout typemap for const std::string&
87081
87082   return jresult;
87083 }
87084
87085
87086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87087   void * jresult ;
87088   Dali::Toolkit::VideoView *result = 0 ;
87089
87090   {
87091     try {
87092       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87093     } catch (std::out_of_range& e) {
87094       {
87095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87096       };
87097     } catch (std::exception& e) {
87098       {
87099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87100       };
87101     } catch (Dali::DaliException e) {
87102       {
87103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87104       };
87105     } catch (...) {
87106       {
87107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87108       };
87109     }
87110   }
87111
87112   jresult = (void *)result;
87113   return jresult;
87114 }
87115
87116
87117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87118   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87119
87120   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87121   {
87122     try {
87123       delete arg1;
87124     } catch (std::out_of_range& e) {
87125       {
87126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87127       };
87128     } catch (std::exception& e) {
87129       {
87130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87131       };
87132     } catch (Dali::DaliException e) {
87133       {
87134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87135       };
87136     } catch (...) {
87137       {
87138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87139       };
87140     }
87141   }
87142
87143 }
87144
87145
87146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87147   void * jresult ;
87148   Dali::Toolkit::VideoView *arg1 = 0 ;
87149   Dali::Toolkit::VideoView *result = 0 ;
87150
87151   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87152   if (!arg1) {
87153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87154     return 0;
87155   }
87156   {
87157     try {
87158       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87159     } catch (std::out_of_range& e) {
87160       {
87161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87162       };
87163     } catch (std::exception& e) {
87164       {
87165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87166       };
87167     } catch (Dali::DaliException e) {
87168       {
87169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87170       };
87171     } catch (...) {
87172       {
87173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87174       };
87175     }
87176   }
87177
87178   jresult = (void *)result;
87179   return jresult;
87180 }
87181
87182
87183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87184   void * jresult ;
87185   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87186   Dali::Toolkit::VideoView *arg2 = 0 ;
87187   Dali::Toolkit::VideoView *result = 0 ;
87188
87189   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87190   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87191   if (!arg2) {
87192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87193     return 0;
87194   }
87195   {
87196     try {
87197       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87198     } catch (std::out_of_range& e) {
87199       {
87200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87201       };
87202     } catch (std::exception& e) {
87203       {
87204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87205       };
87206     } catch (Dali::DaliException e) {
87207       {
87208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87209       };
87210     } catch (...) {
87211       {
87212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87213       };
87214     }
87215   }
87216
87217   jresult = (void *)result;
87218   return jresult;
87219 }
87220
87221
87222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87223   void * jresult ;
87224   Dali::BaseHandle arg1 ;
87225   Dali::BaseHandle *argp1 ;
87226   Dali::Toolkit::VideoView result;
87227
87228   argp1 = (Dali::BaseHandle *)jarg1;
87229   if (!argp1) {
87230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87231     return 0;
87232   }
87233   arg1 = *argp1;
87234   {
87235     try {
87236       result = Dali::Toolkit::VideoView::DownCast(arg1);
87237     } catch (std::out_of_range& e) {
87238       {
87239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87240       };
87241     } catch (std::exception& e) {
87242       {
87243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87244       };
87245     } catch (Dali::DaliException e) {
87246       {
87247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87248       };
87249     } catch (...) {
87250       {
87251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87252       };
87253     }
87254   }
87255
87256   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87257   return jresult;
87258 }
87259
87260
87261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87262   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87263
87264   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87265   {
87266     try {
87267       (arg1)->Play();
87268     } catch (std::out_of_range& e) {
87269       {
87270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87271       };
87272     } catch (std::exception& e) {
87273       {
87274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87275       };
87276     } catch (Dali::DaliException e) {
87277       {
87278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87279       };
87280     } catch (...) {
87281       {
87282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87283       };
87284     }
87285   }
87286
87287 }
87288
87289
87290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87291   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87292
87293   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87294   {
87295     try {
87296       (arg1)->Pause();
87297     } catch (std::out_of_range& e) {
87298       {
87299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87300       };
87301     } catch (std::exception& e) {
87302       {
87303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87304       };
87305     } catch (Dali::DaliException e) {
87306       {
87307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87308       };
87309     } catch (...) {
87310       {
87311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87312       };
87313     }
87314   }
87315
87316 }
87317
87318
87319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87320   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87321
87322   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87323   {
87324     try {
87325       (arg1)->Stop();
87326     } catch (std::out_of_range& e) {
87327       {
87328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87329       };
87330     } catch (std::exception& e) {
87331       {
87332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87333       };
87334     } catch (Dali::DaliException e) {
87335       {
87336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87337       };
87338     } catch (...) {
87339       {
87340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87341       };
87342     }
87343   }
87344
87345 }
87346
87347
87348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87349   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87350   int arg2 ;
87351
87352   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87353   arg2 = (int)jarg2;
87354   {
87355     try {
87356       (arg1)->Forward(arg2);
87357     } catch (std::out_of_range& e) {
87358       {
87359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87360       };
87361     } catch (std::exception& e) {
87362       {
87363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87364       };
87365     } catch (Dali::DaliException e) {
87366       {
87367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87368       };
87369     } catch (...) {
87370       {
87371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87372       };
87373     }
87374   }
87375
87376 }
87377
87378
87379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87380   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87381   int arg2 ;
87382
87383   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87384   arg2 = (int)jarg2;
87385   {
87386     try {
87387       (arg1)->Backward(arg2);
87388     } catch (std::out_of_range& e) {
87389       {
87390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87391       };
87392     } catch (std::exception& e) {
87393       {
87394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87395       };
87396     } catch (Dali::DaliException e) {
87397       {
87398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87399       };
87400     } catch (...) {
87401       {
87402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87403       };
87404     }
87405   }
87406
87407 }
87408
87409
87410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87411   void * jresult ;
87412   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87413   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87414
87415   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87416   {
87417     try {
87418       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87419     } catch (std::out_of_range& e) {
87420       {
87421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87422       };
87423     } catch (std::exception& e) {
87424       {
87425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87426       };
87427     } catch (Dali::DaliException e) {
87428       {
87429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87430       };
87431     } catch (...) {
87432       {
87433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87434       };
87435     }
87436   }
87437
87438   jresult = (void *)result;
87439   return jresult;
87440 }
87441
87442
87443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87444   int jresult ;
87445   int result;
87446
87447   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87448   jresult = (int)result;
87449   return jresult;
87450 }
87451
87452
87453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87454   int jresult ;
87455   int result;
87456
87457   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87458   jresult = (int)result;
87459   return jresult;
87460 }
87461
87462
87463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87464   int jresult ;
87465   int result;
87466
87467   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87468   jresult = (int)result;
87469   return jresult;
87470 }
87471
87472
87473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87474   int jresult ;
87475   int result;
87476
87477   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87478   jresult = (int)result;
87479   return jresult;
87480 }
87481
87482
87483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87484   int jresult ;
87485   int result;
87486
87487   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87488   jresult = (int)result;
87489   return jresult;
87490 }
87491
87492
87493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87494   int jresult ;
87495   int result;
87496
87497   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87498   jresult = (int)result;
87499   return jresult;
87500 }
87501
87502
87503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87504   int jresult ;
87505   int result;
87506
87507   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87508   jresult = (int)result;
87509   return jresult;
87510 }
87511
87512
87513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87514   int jresult ;
87515   int result;
87516
87517   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87518   jresult = (int)result;
87519   return jresult;
87520 }
87521
87522
87523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87524   int jresult ;
87525   int result;
87526
87527   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87528   jresult = (int)result;
87529   return jresult;
87530 }
87531
87532
87533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87534   int jresult ;
87535   int result;
87536
87537   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87538   jresult = (int)result;
87539   return jresult;
87540 }
87541
87542
87543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87544   int jresult ;
87545   int result;
87546
87547   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87548   jresult = (int)result;
87549   return jresult;
87550 }
87551
87552
87553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87554   int jresult ;
87555   int result;
87556
87557   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87558   jresult = (int)result;
87559   return jresult;
87560 }
87561
87562
87563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87564   int jresult ;
87565   int result;
87566
87567   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87568   jresult = (int)result;
87569   return jresult;
87570 }
87571
87572
87573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87574   int jresult ;
87575   int result;
87576
87577   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87578   jresult = (int)result;
87579   return jresult;
87580 }
87581
87582
87583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87584   int jresult ;
87585   int result;
87586
87587   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87588   jresult = (int)result;
87589   return jresult;
87590 }
87591
87592
87593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87594   int jresult ;
87595   int result;
87596
87597   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87598   jresult = (int)result;
87599   return jresult;
87600 }
87601
87602
87603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87604   int jresult ;
87605   int result;
87606
87607   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87608   jresult = (int)result;
87609   return jresult;
87610 }
87611
87612
87613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87614   int jresult ;
87615   int result;
87616
87617   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87618   jresult = (int)result;
87619   return jresult;
87620 }
87621
87622
87623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87624   int jresult ;
87625   int result;
87626
87627   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87628   jresult = (int)result;
87629   return jresult;
87630 }
87631
87632
87633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87634   int jresult ;
87635   int result;
87636
87637   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87638   jresult = (int)result;
87639   return jresult;
87640 }
87641
87642
87643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87644   int jresult ;
87645   int result;
87646
87647   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87648   jresult = (int)result;
87649   return jresult;
87650 }
87651
87652
87653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87654   void * jresult ;
87655   Dali::Toolkit::Popup::Property *result = 0 ;
87656
87657   {
87658     try {
87659       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87660     } catch (std::out_of_range& e) {
87661       {
87662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87663       };
87664     } catch (std::exception& e) {
87665       {
87666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87667       };
87668     } catch (Dali::DaliException e) {
87669       {
87670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87671       };
87672     } catch (...) {
87673       {
87674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87675       };
87676     }
87677   }
87678
87679   jresult = (void *)result;
87680   return jresult;
87681 }
87682
87683
87684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87685   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87686
87687   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87688   {
87689     try {
87690       delete arg1;
87691     } catch (std::out_of_range& e) {
87692       {
87693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87694       };
87695     } catch (std::exception& e) {
87696       {
87697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87698       };
87699     } catch (Dali::DaliException e) {
87700       {
87701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87702       };
87703     } catch (...) {
87704       {
87705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87706       };
87707     }
87708   }
87709
87710 }
87711
87712
87713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87714   void * jresult ;
87715   Dali::Toolkit::Popup *result = 0 ;
87716
87717   {
87718     try {
87719       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87720     } catch (std::out_of_range& e) {
87721       {
87722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87723       };
87724     } catch (std::exception& e) {
87725       {
87726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87727       };
87728     } catch (Dali::DaliException e) {
87729       {
87730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87731       };
87732     } catch (...) {
87733       {
87734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87735       };
87736     }
87737   }
87738
87739   jresult = (void *)result;
87740   return jresult;
87741 }
87742
87743
87744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87745   void * jresult ;
87746   Dali::Toolkit::Popup result;
87747
87748   {
87749     try {
87750       result = Dali::Toolkit::Popup::New();
87751     } catch (std::out_of_range& e) {
87752       {
87753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87754       };
87755     } catch (std::exception& e) {
87756       {
87757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87758       };
87759     } catch (Dali::DaliException e) {
87760       {
87761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87762       };
87763     } catch (...) {
87764       {
87765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87766       };
87767     }
87768   }
87769
87770   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87771   return jresult;
87772 }
87773
87774
87775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87776   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87777
87778   arg1 = (Dali::Toolkit::Popup *)jarg1;
87779   {
87780     try {
87781       delete arg1;
87782     } catch (std::out_of_range& e) {
87783       {
87784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87785       };
87786     } catch (std::exception& e) {
87787       {
87788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87789       };
87790     } catch (Dali::DaliException e) {
87791       {
87792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87793       };
87794     } catch (...) {
87795       {
87796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87797       };
87798     }
87799   }
87800
87801 }
87802
87803
87804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87805   void * jresult ;
87806   Dali::Toolkit::Popup *arg1 = 0 ;
87807   Dali::Toolkit::Popup *result = 0 ;
87808
87809   arg1 = (Dali::Toolkit::Popup *)jarg1;
87810   if (!arg1) {
87811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87812     return 0;
87813   }
87814   {
87815     try {
87816       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87817     } catch (std::out_of_range& e) {
87818       {
87819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87820       };
87821     } catch (std::exception& e) {
87822       {
87823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87824       };
87825     } catch (Dali::DaliException e) {
87826       {
87827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87828       };
87829     } catch (...) {
87830       {
87831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87832       };
87833     }
87834   }
87835
87836   jresult = (void *)result;
87837   return jresult;
87838 }
87839
87840
87841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87842   void * jresult ;
87843   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87844   Dali::Toolkit::Popup *arg2 = 0 ;
87845   Dali::Toolkit::Popup *result = 0 ;
87846
87847   arg1 = (Dali::Toolkit::Popup *)jarg1;
87848   arg2 = (Dali::Toolkit::Popup *)jarg2;
87849   if (!arg2) {
87850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87851     return 0;
87852   }
87853   {
87854     try {
87855       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87856     } catch (std::out_of_range& e) {
87857       {
87858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87859       };
87860     } catch (std::exception& e) {
87861       {
87862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87863       };
87864     } catch (Dali::DaliException e) {
87865       {
87866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87867       };
87868     } catch (...) {
87869       {
87870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87871       };
87872     }
87873   }
87874
87875   jresult = (void *)result;
87876   return jresult;
87877 }
87878
87879
87880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87881   void * jresult ;
87882   Dali::BaseHandle arg1 ;
87883   Dali::BaseHandle *argp1 ;
87884   Dali::Toolkit::Popup result;
87885
87886   argp1 = (Dali::BaseHandle *)jarg1;
87887   if (!argp1) {
87888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87889     return 0;
87890   }
87891   arg1 = *argp1;
87892   {
87893     try {
87894       result = Dali::Toolkit::Popup::DownCast(arg1);
87895     } catch (std::out_of_range& e) {
87896       {
87897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87898       };
87899     } catch (std::exception& e) {
87900       {
87901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87902       };
87903     } catch (Dali::DaliException e) {
87904       {
87905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87906       };
87907     } catch (...) {
87908       {
87909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87910       };
87911     }
87912   }
87913
87914   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87915   return jresult;
87916 }
87917
87918
87919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87920   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87921   Dali::Actor arg2 ;
87922   Dali::Actor *argp2 ;
87923
87924   arg1 = (Dali::Toolkit::Popup *)jarg1;
87925   argp2 = (Dali::Actor *)jarg2;
87926   if (!argp2) {
87927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87928     return ;
87929   }
87930   arg2 = *argp2;
87931   {
87932     try {
87933       (arg1)->SetTitle(arg2);
87934     } catch (std::out_of_range& e) {
87935       {
87936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87937       };
87938     } catch (std::exception& e) {
87939       {
87940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87941       };
87942     } catch (Dali::DaliException e) {
87943       {
87944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87945       };
87946     } catch (...) {
87947       {
87948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87949       };
87950     }
87951   }
87952
87953 }
87954
87955
87956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87957   void * jresult ;
87958   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87959   Dali::Actor result;
87960
87961   arg1 = (Dali::Toolkit::Popup *)jarg1;
87962   {
87963     try {
87964       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87965     } catch (std::out_of_range& e) {
87966       {
87967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87968       };
87969     } catch (std::exception& e) {
87970       {
87971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87972       };
87973     } catch (Dali::DaliException e) {
87974       {
87975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87976       };
87977     } catch (...) {
87978       {
87979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87980       };
87981     }
87982   }
87983
87984   jresult = new Dali::Actor((const Dali::Actor &)result);
87985   return jresult;
87986 }
87987
87988
87989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87990   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87991   Dali::Actor arg2 ;
87992   Dali::Actor *argp2 ;
87993
87994   arg1 = (Dali::Toolkit::Popup *)jarg1;
87995   argp2 = (Dali::Actor *)jarg2;
87996   if (!argp2) {
87997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87998     return ;
87999   }
88000   arg2 = *argp2;
88001   {
88002     try {
88003       (arg1)->SetContent(arg2);
88004     } catch (std::out_of_range& e) {
88005       {
88006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88007       };
88008     } catch (std::exception& e) {
88009       {
88010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88011       };
88012     } catch (Dali::DaliException e) {
88013       {
88014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88015       };
88016     } catch (...) {
88017       {
88018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88019       };
88020     }
88021   }
88022
88023 }
88024
88025
88026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88027   void * jresult ;
88028   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88029   Dali::Actor result;
88030
88031   arg1 = (Dali::Toolkit::Popup *)jarg1;
88032   {
88033     try {
88034       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88035     } catch (std::out_of_range& e) {
88036       {
88037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88038       };
88039     } catch (std::exception& e) {
88040       {
88041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88042       };
88043     } catch (Dali::DaliException e) {
88044       {
88045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88046       };
88047     } catch (...) {
88048       {
88049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88050       };
88051     }
88052   }
88053
88054   jresult = new Dali::Actor((const Dali::Actor &)result);
88055   return jresult;
88056 }
88057
88058
88059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88060   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88061   Dali::Actor arg2 ;
88062   Dali::Actor *argp2 ;
88063
88064   arg1 = (Dali::Toolkit::Popup *)jarg1;
88065   argp2 = (Dali::Actor *)jarg2;
88066   if (!argp2) {
88067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88068     return ;
88069   }
88070   arg2 = *argp2;
88071   {
88072     try {
88073       (arg1)->SetFooter(arg2);
88074     } catch (std::out_of_range& e) {
88075       {
88076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88077       };
88078     } catch (std::exception& e) {
88079       {
88080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88081       };
88082     } catch (Dali::DaliException e) {
88083       {
88084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88085       };
88086     } catch (...) {
88087       {
88088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88089       };
88090     }
88091   }
88092
88093 }
88094
88095
88096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88097   void * jresult ;
88098   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88099   Dali::Actor result;
88100
88101   arg1 = (Dali::Toolkit::Popup *)jarg1;
88102   {
88103     try {
88104       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88105     } catch (std::out_of_range& e) {
88106       {
88107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88108       };
88109     } catch (std::exception& e) {
88110       {
88111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88112       };
88113     } catch (Dali::DaliException e) {
88114       {
88115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88116       };
88117     } catch (...) {
88118       {
88119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88120       };
88121     }
88122   }
88123
88124   jresult = new Dali::Actor((const Dali::Actor &)result);
88125   return jresult;
88126 }
88127
88128
88129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88130   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88131   Dali::Toolkit::Popup::DisplayState arg2 ;
88132
88133   arg1 = (Dali::Toolkit::Popup *)jarg1;
88134   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88135   {
88136     try {
88137       (arg1)->SetDisplayState(arg2);
88138     } catch (std::out_of_range& e) {
88139       {
88140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88141       };
88142     } catch (std::exception& e) {
88143       {
88144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88145       };
88146     } catch (Dali::DaliException e) {
88147       {
88148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88149       };
88150     } catch (...) {
88151       {
88152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88153       };
88154     }
88155   }
88156
88157 }
88158
88159
88160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88161   int jresult ;
88162   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88163   Dali::Toolkit::Popup::DisplayState result;
88164
88165   arg1 = (Dali::Toolkit::Popup *)jarg1;
88166   {
88167     try {
88168       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88169     } catch (std::out_of_range& e) {
88170       {
88171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88172       };
88173     } catch (std::exception& e) {
88174       {
88175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88176       };
88177     } catch (Dali::DaliException e) {
88178       {
88179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88180       };
88181     } catch (...) {
88182       {
88183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88184       };
88185     }
88186   }
88187
88188   jresult = (int)result;
88189   return jresult;
88190 }
88191
88192
88193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88194   void * jresult ;
88195   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88196   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88197
88198   arg1 = (Dali::Toolkit::Popup *)jarg1;
88199   {
88200     try {
88201       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88202     } catch (std::out_of_range& e) {
88203       {
88204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88205       };
88206     } catch (std::exception& e) {
88207       {
88208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88209       };
88210     } catch (Dali::DaliException e) {
88211       {
88212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88213       };
88214     } catch (...) {
88215       {
88216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88217       };
88218     }
88219   }
88220
88221   jresult = (void *)result;
88222   return jresult;
88223 }
88224
88225
88226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88227   void * jresult ;
88228   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88229   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88230
88231   arg1 = (Dali::Toolkit::Popup *)jarg1;
88232   {
88233     try {
88234       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88235     } catch (std::out_of_range& e) {
88236       {
88237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88238       };
88239     } catch (std::exception& e) {
88240       {
88241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88242       };
88243     } catch (Dali::DaliException e) {
88244       {
88245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88246       };
88247     } catch (...) {
88248       {
88249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88250       };
88251     }
88252   }
88253
88254   jresult = (void *)result;
88255   return jresult;
88256 }
88257
88258
88259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88260   void * jresult ;
88261   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88262   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88263
88264   arg1 = (Dali::Toolkit::Popup *)jarg1;
88265   {
88266     try {
88267       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88268     } catch (std::out_of_range& e) {
88269       {
88270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88271       };
88272     } catch (std::exception& e) {
88273       {
88274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88275       };
88276     } catch (Dali::DaliException e) {
88277       {
88278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88279       };
88280     } catch (...) {
88281       {
88282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88283       };
88284     }
88285   }
88286
88287   jresult = (void *)result;
88288   return jresult;
88289 }
88290
88291
88292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88293   void * jresult ;
88294   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88295   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88296
88297   arg1 = (Dali::Toolkit::Popup *)jarg1;
88298   {
88299     try {
88300       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88301     } catch (std::out_of_range& e) {
88302       {
88303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88304       };
88305     } catch (std::exception& e) {
88306       {
88307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88308       };
88309     } catch (Dali::DaliException e) {
88310       {
88311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88312       };
88313     } catch (...) {
88314       {
88315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88316       };
88317     }
88318   }
88319
88320   jresult = (void *)result;
88321   return jresult;
88322 }
88323
88324
88325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88326   void * jresult ;
88327   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88328   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88329
88330   arg1 = (Dali::Toolkit::Popup *)jarg1;
88331   {
88332     try {
88333       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88334     } catch (std::out_of_range& e) {
88335       {
88336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88337       };
88338     } catch (std::exception& e) {
88339       {
88340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88341       };
88342     } catch (Dali::DaliException e) {
88343       {
88344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88345       };
88346     } catch (...) {
88347       {
88348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88349       };
88350     }
88351   }
88352
88353   jresult = (void *)result;
88354   return jresult;
88355 }
88356
88357
88358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88359   int jresult ;
88360   int result;
88361
88362   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88363   jresult = (int)result;
88364   return jresult;
88365 }
88366
88367
88368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88369   int jresult ;
88370   int result;
88371
88372   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88373   jresult = (int)result;
88374   return jresult;
88375 }
88376
88377
88378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88379   int jresult ;
88380   int result;
88381
88382   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88383   jresult = (int)result;
88384   return jresult;
88385 }
88386
88387
88388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88389   int jresult ;
88390   int result;
88391
88392   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88393   jresult = (int)result;
88394   return jresult;
88395 }
88396
88397
88398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88399   int jresult ;
88400   int result;
88401
88402   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88403   jresult = (int)result;
88404   return jresult;
88405 }
88406
88407
88408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88409   int jresult ;
88410   int result;
88411
88412   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88413   jresult = (int)result;
88414   return jresult;
88415 }
88416
88417
88418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88419   int jresult ;
88420   int result;
88421
88422   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88423   jresult = (int)result;
88424   return jresult;
88425 }
88426
88427
88428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88429   int jresult ;
88430   int result;
88431
88432   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88433   jresult = (int)result;
88434   return jresult;
88435 }
88436
88437
88438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88439   int jresult ;
88440   int result;
88441
88442   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88443   jresult = (int)result;
88444   return jresult;
88445 }
88446
88447
88448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88449   void * jresult ;
88450   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88451
88452   {
88453     try {
88454       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88455     } catch (std::out_of_range& e) {
88456       {
88457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88458       };
88459     } catch (std::exception& e) {
88460       {
88461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88462       };
88463     } catch (Dali::DaliException e) {
88464       {
88465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88466       };
88467     } catch (...) {
88468       {
88469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88470       };
88471     }
88472   }
88473
88474   jresult = (void *)result;
88475   return jresult;
88476 }
88477
88478
88479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88480   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88481
88482   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88483   {
88484     try {
88485       delete arg1;
88486     } catch (std::out_of_range& e) {
88487       {
88488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88489       };
88490     } catch (std::exception& e) {
88491       {
88492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88493       };
88494     } catch (Dali::DaliException e) {
88495       {
88496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88497       };
88498     } catch (...) {
88499       {
88500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88501       };
88502     }
88503   }
88504
88505 }
88506
88507
88508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88509   void * jresult ;
88510   Dali::Toolkit::ProgressBar result;
88511
88512   {
88513     try {
88514       result = Dali::Toolkit::ProgressBar::New();
88515     } catch (std::out_of_range& e) {
88516       {
88517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88518       };
88519     } catch (std::exception& e) {
88520       {
88521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88522       };
88523     } catch (Dali::DaliException e) {
88524       {
88525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88526       };
88527     } catch (...) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88530       };
88531     }
88532   }
88533
88534   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88535   return jresult;
88536 }
88537
88538
88539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88540   void * jresult ;
88541   Dali::Toolkit::ProgressBar *result = 0 ;
88542
88543   {
88544     try {
88545       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88546     } catch (std::out_of_range& e) {
88547       {
88548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88549       };
88550     } catch (std::exception& e) {
88551       {
88552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88553       };
88554     } catch (Dali::DaliException e) {
88555       {
88556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88557       };
88558     } catch (...) {
88559       {
88560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88561       };
88562     }
88563   }
88564
88565   jresult = (void *)result;
88566   return jresult;
88567 }
88568
88569
88570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88571   void * jresult ;
88572   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88573   Dali::Toolkit::ProgressBar *result = 0 ;
88574
88575   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88576   if (!arg1) {
88577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88578     return 0;
88579   }
88580   {
88581     try {
88582       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88583     } catch (std::out_of_range& e) {
88584       {
88585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88586       };
88587     } catch (std::exception& e) {
88588       {
88589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88590       };
88591     } catch (Dali::DaliException e) {
88592       {
88593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88594       };
88595     } catch (...) {
88596       {
88597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88598       };
88599     }
88600   }
88601
88602   jresult = (void *)result;
88603   return jresult;
88604 }
88605
88606
88607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88608   void * jresult ;
88609   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88610   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88611   Dali::Toolkit::ProgressBar *result = 0 ;
88612
88613   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88614   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88615   if (!arg2) {
88616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88617     return 0;
88618   }
88619   {
88620     try {
88621       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88622     } catch (std::out_of_range& e) {
88623       {
88624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88625       };
88626     } catch (std::exception& e) {
88627       {
88628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88629       };
88630     } catch (Dali::DaliException e) {
88631       {
88632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88633       };
88634     } catch (...) {
88635       {
88636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88637       };
88638     }
88639   }
88640
88641   jresult = (void *)result;
88642   return jresult;
88643 }
88644
88645
88646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88647   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88648
88649   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88650   {
88651     try {
88652       delete arg1;
88653     } catch (std::out_of_range& e) {
88654       {
88655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88656       };
88657     } catch (std::exception& e) {
88658       {
88659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88660       };
88661     } catch (Dali::DaliException e) {
88662       {
88663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88664       };
88665     } catch (...) {
88666       {
88667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88668       };
88669     }
88670   }
88671
88672 }
88673
88674
88675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88676   void * jresult ;
88677   Dali::BaseHandle arg1 ;
88678   Dali::BaseHandle *argp1 ;
88679   Dali::Toolkit::ProgressBar result;
88680
88681   argp1 = (Dali::BaseHandle *)jarg1;
88682   if (!argp1) {
88683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88684     return 0;
88685   }
88686   arg1 = *argp1;
88687   {
88688     try {
88689       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88690     } catch (std::out_of_range& e) {
88691       {
88692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88693       };
88694     } catch (std::exception& e) {
88695       {
88696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88697       };
88698     } catch (Dali::DaliException e) {
88699       {
88700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88701       };
88702     } catch (...) {
88703       {
88704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88705       };
88706     }
88707   }
88708
88709   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88710   return jresult;
88711 }
88712
88713
88714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88715   void * jresult ;
88716   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88717   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88718
88719   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88720   {
88721     try {
88722       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88723     } catch (std::out_of_range& e) {
88724       {
88725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88726       };
88727     } catch (std::exception& e) {
88728       {
88729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88730       };
88731     } catch (Dali::DaliException e) {
88732       {
88733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88734       };
88735     } catch (...) {
88736       {
88737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88738       };
88739     }
88740   }
88741
88742   jresult = (void *)result;
88743   return jresult;
88744 }
88745
88746
88747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88748   void * jresult ;
88749   Dali::Toolkit::GaussianBlurView *result = 0 ;
88750
88751   {
88752     try {
88753       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88754     } catch (std::out_of_range& e) {
88755       {
88756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88757       };
88758     } catch (std::exception& e) {
88759       {
88760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88761       };
88762     } catch (Dali::DaliException e) {
88763       {
88764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88765       };
88766     } catch (...) {
88767       {
88768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88769       };
88770     }
88771   }
88772
88773   jresult = (void *)result;
88774   return jresult;
88775 }
88776
88777
88778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88779   void * jresult ;
88780   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88781   Dali::Toolkit::GaussianBlurView *result = 0 ;
88782
88783   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88784   if (!arg1) {
88785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88786     return 0;
88787   }
88788   {
88789     try {
88790       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88791     } catch (std::out_of_range& e) {
88792       {
88793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88794       };
88795     } catch (std::exception& e) {
88796       {
88797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88798       };
88799     } catch (Dali::DaliException e) {
88800       {
88801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88802       };
88803     } catch (...) {
88804       {
88805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88806       };
88807     }
88808   }
88809
88810   jresult = (void *)result;
88811   return jresult;
88812 }
88813
88814
88815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88816   void * jresult ;
88817   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88818   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88819   Dali::Toolkit::GaussianBlurView *result = 0 ;
88820
88821   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88822   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88823   if (!arg2) {
88824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88825     return 0;
88826   }
88827   {
88828     try {
88829       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88830     } catch (std::out_of_range& e) {
88831       {
88832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88833       };
88834     } catch (std::exception& e) {
88835       {
88836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88837       };
88838     } catch (Dali::DaliException e) {
88839       {
88840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88841       };
88842     } catch (...) {
88843       {
88844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88845       };
88846     }
88847   }
88848
88849   jresult = (void *)result;
88850   return jresult;
88851 }
88852
88853
88854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88855   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88856
88857   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88858   {
88859     try {
88860       delete arg1;
88861     } catch (std::out_of_range& e) {
88862       {
88863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88864       };
88865     } catch (std::exception& e) {
88866       {
88867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88868       };
88869     } catch (Dali::DaliException e) {
88870       {
88871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88872       };
88873     } catch (...) {
88874       {
88875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88876       };
88877     }
88878   }
88879
88880 }
88881
88882
88883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88884   void * jresult ;
88885   Dali::BaseHandle arg1 ;
88886   Dali::BaseHandle *argp1 ;
88887   Dali::Toolkit::GaussianBlurView result;
88888
88889   argp1 = (Dali::BaseHandle *)jarg1;
88890   if (!argp1) {
88891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88892     return 0;
88893   }
88894   arg1 = *argp1;
88895   {
88896     try {
88897       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88898     } catch (std::out_of_range& e) {
88899       {
88900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88901       };
88902     } catch (std::exception& e) {
88903       {
88904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88905       };
88906     } catch (Dali::DaliException e) {
88907       {
88908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88909       };
88910     } catch (...) {
88911       {
88912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88913       };
88914     }
88915   }
88916
88917   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88918   return jresult;
88919 }
88920
88921
88922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88923   void * jresult ;
88924   Dali::Toolkit::GaussianBlurView result;
88925
88926   {
88927     try {
88928       result = Dali::Toolkit::GaussianBlurView::New();
88929     } catch (std::out_of_range& e) {
88930       {
88931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88932       };
88933     } catch (std::exception& e) {
88934       {
88935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88936       };
88937     } catch (Dali::DaliException e) {
88938       {
88939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88940       };
88941     } catch (...) {
88942       {
88943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88944       };
88945     }
88946   }
88947
88948   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88949   return jresult;
88950 }
88951
88952
88953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88954   void * jresult ;
88955   unsigned int arg1 ;
88956   float arg2 ;
88957   Dali::Pixel::Format arg3 ;
88958   float arg4 ;
88959   float arg5 ;
88960   bool arg6 ;
88961   Dali::Toolkit::GaussianBlurView result;
88962
88963   arg1 = (unsigned int)jarg1;
88964   arg2 = (float)jarg2;
88965   arg3 = (Dali::Pixel::Format)jarg3;
88966   arg4 = (float)jarg4;
88967   arg5 = (float)jarg5;
88968   arg6 = jarg6 ? true : false;
88969   {
88970     try {
88971       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88972     } catch (std::out_of_range& e) {
88973       {
88974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88975       };
88976     } catch (std::exception& e) {
88977       {
88978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88979       };
88980     } catch (Dali::DaliException e) {
88981       {
88982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88983       };
88984     } catch (...) {
88985       {
88986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88987       };
88988     }
88989   }
88990
88991   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88992   return jresult;
88993 }
88994
88995
88996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88997   void * jresult ;
88998   unsigned int arg1 ;
88999   float arg2 ;
89000   Dali::Pixel::Format arg3 ;
89001   float arg4 ;
89002   float arg5 ;
89003   Dali::Toolkit::GaussianBlurView result;
89004
89005   arg1 = (unsigned int)jarg1;
89006   arg2 = (float)jarg2;
89007   arg3 = (Dali::Pixel::Format)jarg3;
89008   arg4 = (float)jarg4;
89009   arg5 = (float)jarg5;
89010   {
89011     try {
89012       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89013     } catch (std::out_of_range& e) {
89014       {
89015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89016       };
89017     } catch (std::exception& e) {
89018       {
89019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89020       };
89021     } catch (Dali::DaliException e) {
89022       {
89023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89024       };
89025     } catch (...) {
89026       {
89027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89028       };
89029     }
89030   }
89031
89032   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89033   return jresult;
89034 }
89035
89036
89037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89038   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89039   Dali::Actor arg2 ;
89040   Dali::Actor *argp2 ;
89041
89042   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89043   argp2 = (Dali::Actor *)jarg2;
89044   if (!argp2) {
89045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89046     return ;
89047   }
89048   arg2 = *argp2;
89049   {
89050     try {
89051       (arg1)->Add(arg2);
89052     } catch (std::out_of_range& e) {
89053       {
89054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89055       };
89056     } catch (std::exception& e) {
89057       {
89058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89059       };
89060     } catch (Dali::DaliException e) {
89061       {
89062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89063       };
89064     } catch (...) {
89065       {
89066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89067       };
89068     }
89069   }
89070
89071 }
89072
89073
89074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89075   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89076   Dali::Actor arg2 ;
89077   Dali::Actor *argp2 ;
89078
89079   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89080   argp2 = (Dali::Actor *)jarg2;
89081   if (!argp2) {
89082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89083     return ;
89084   }
89085   arg2 = *argp2;
89086   {
89087     try {
89088       (arg1)->Remove(arg2);
89089     } catch (std::out_of_range& e) {
89090       {
89091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89092       };
89093     } catch (std::exception& e) {
89094       {
89095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89096       };
89097     } catch (Dali::DaliException e) {
89098       {
89099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89100       };
89101     } catch (...) {
89102       {
89103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89104       };
89105     }
89106   }
89107
89108 }
89109
89110
89111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89112   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89113
89114   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89115   {
89116     try {
89117       (arg1)->Activate();
89118     } catch (std::out_of_range& e) {
89119       {
89120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89121       };
89122     } catch (std::exception& e) {
89123       {
89124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89125       };
89126     } catch (Dali::DaliException e) {
89127       {
89128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89129       };
89130     } catch (...) {
89131       {
89132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89133       };
89134     }
89135   }
89136
89137 }
89138
89139
89140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89141   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89142
89143   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89144   {
89145     try {
89146       (arg1)->ActivateOnce();
89147     } catch (std::out_of_range& e) {
89148       {
89149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89150       };
89151     } catch (std::exception& e) {
89152       {
89153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89154       };
89155     } catch (Dali::DaliException e) {
89156       {
89157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89158       };
89159     } catch (...) {
89160       {
89161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89162       };
89163     }
89164   }
89165
89166 }
89167
89168
89169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89170   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89171
89172   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89173   {
89174     try {
89175       (arg1)->Deactivate();
89176     } catch (std::out_of_range& e) {
89177       {
89178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89179       };
89180     } catch (std::exception& e) {
89181       {
89182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89183       };
89184     } catch (Dali::DaliException e) {
89185       {
89186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89187       };
89188     } catch (...) {
89189       {
89190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89191       };
89192     }
89193   }
89194
89195 }
89196
89197
89198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89199   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89200   Dali::Texture arg2 ;
89201   Dali::FrameBuffer arg3 ;
89202   Dali::Texture *argp2 ;
89203   Dali::FrameBuffer *argp3 ;
89204
89205   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89206   argp2 = (Dali::Texture *)jarg2;
89207   if (!argp2) {
89208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
89209     return ;
89210   }
89211   arg2 = *argp2;
89212   argp3 = (Dali::FrameBuffer *)jarg3;
89213   if (!argp3) {
89214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
89215     return ;
89216   }
89217   arg3 = *argp3;
89218   {
89219     try {
89220       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89221     } catch (std::out_of_range& e) {
89222       {
89223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89224       };
89225     } catch (std::exception& e) {
89226       {
89227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89228       };
89229     } catch (Dali::DaliException e) {
89230       {
89231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89232       };
89233     } catch (...) {
89234       {
89235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89236       };
89237     }
89238   }
89239
89240 }
89241
89242
89243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89244   int jresult ;
89245   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89246   Dali::Property::Index result;
89247
89248   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89249   {
89250     try {
89251       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89252     } catch (std::out_of_range& e) {
89253       {
89254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89255       };
89256     } catch (std::exception& e) {
89257       {
89258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89259       };
89260     } catch (Dali::DaliException e) {
89261       {
89262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89263       };
89264     } catch (...) {
89265       {
89266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89267       };
89268     }
89269   }
89270
89271   jresult = result;
89272   return jresult;
89273 }
89274
89275
89276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89277   void * jresult ;
89278   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89279   Dali::FrameBuffer result;
89280
89281   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89282   {
89283     try {
89284       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89285     } catch (std::out_of_range& e) {
89286       {
89287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89288       };
89289     } catch (std::exception& e) {
89290       {
89291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89292       };
89293     } catch (Dali::DaliException e) {
89294       {
89295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89296       };
89297     } catch (...) {
89298       {
89299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89300       };
89301     }
89302   }
89303
89304   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
89305   return jresult;
89306 }
89307
89308
89309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89310   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89311   Dali::Vector4 *arg2 = 0 ;
89312
89313   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89314   arg2 = (Dali::Vector4 *)jarg2;
89315   if (!arg2) {
89316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89317     return ;
89318   }
89319   {
89320     try {
89321       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89322     } catch (std::out_of_range& e) {
89323       {
89324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89325       };
89326     } catch (std::exception& e) {
89327       {
89328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89329       };
89330     } catch (Dali::DaliException e) {
89331       {
89332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89333       };
89334     } catch (...) {
89335       {
89336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89337       };
89338     }
89339   }
89340
89341 }
89342
89343
89344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89345   void * jresult ;
89346   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89347   Dali::Vector4 result;
89348
89349   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89350   {
89351     try {
89352       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89353     } catch (std::out_of_range& e) {
89354       {
89355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89356       };
89357     } catch (std::exception& e) {
89358       {
89359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89360       };
89361     } catch (Dali::DaliException e) {
89362       {
89363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89364       };
89365     } catch (...) {
89366       {
89367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89368       };
89369     }
89370   }
89371
89372   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89373   return jresult;
89374 }
89375
89376
89377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89378   void * jresult ;
89379   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89380   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89381
89382   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89383   {
89384     try {
89385       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89386     } catch (std::out_of_range& e) {
89387       {
89388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89389       };
89390     } catch (std::exception& e) {
89391       {
89392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89393       };
89394     } catch (Dali::DaliException e) {
89395       {
89396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89397       };
89398     } catch (...) {
89399       {
89400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89401       };
89402     }
89403   }
89404
89405   jresult = (void *)result;
89406   return jresult;
89407 }
89408
89409
89410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89411   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89412
89413   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89414   {
89415     try {
89416       delete arg1;
89417     } catch (std::out_of_range& e) {
89418       {
89419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89420       };
89421     } catch (std::exception& e) {
89422       {
89423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89424       };
89425     } catch (Dali::DaliException e) {
89426       {
89427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89428       };
89429     } catch (...) {
89430       {
89431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89432       };
89433     }
89434   }
89435
89436 }
89437
89438
89439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89440   unsigned int jresult ;
89441   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89442   unsigned int result;
89443
89444   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89445   {
89446     try {
89447       result = (unsigned int)(arg1)->GetNumberOfPages();
89448     } catch (std::out_of_range& e) {
89449       {
89450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89451       };
89452     } catch (std::exception& e) {
89453       {
89454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89455       };
89456     } catch (Dali::DaliException e) {
89457       {
89458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89459       };
89460     } catch (...) {
89461       {
89462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89463       };
89464     }
89465   }
89466
89467   jresult = result;
89468   return jresult;
89469 }
89470
89471
89472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89473   void * jresult ;
89474   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89475   unsigned int arg2 ;
89476   Dali::Texture result;
89477
89478   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89479   arg2 = (unsigned int)jarg2;
89480   {
89481     try {
89482       result = (arg1)->NewPage(arg2);
89483     } catch (std::out_of_range& e) {
89484       {
89485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89486       };
89487     } catch (std::exception& e) {
89488       {
89489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89490       };
89491     } catch (Dali::DaliException e) {
89492       {
89493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89494       };
89495     } catch (...) {
89496       {
89497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89498       };
89499     }
89500   }
89501
89502   jresult = new Dali::Texture((const Dali::Texture &)result);
89503   return jresult;
89504 }
89505
89506
89507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
89508   int jresult ;
89509   int result;
89510
89511   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
89512   jresult = (int)result;
89513   return jresult;
89514 }
89515
89516
89517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89518   int jresult ;
89519   int result;
89520
89521   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89522   jresult = (int)result;
89523   return jresult;
89524 }
89525
89526
89527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89528   int jresult ;
89529   int result;
89530
89531   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89532   jresult = (int)result;
89533   return jresult;
89534 }
89535
89536
89537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89538   void * jresult ;
89539   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89540
89541   {
89542     try {
89543       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89544     } catch (std::out_of_range& e) {
89545       {
89546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89547       };
89548     } catch (std::exception& e) {
89549       {
89550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89551       };
89552     } catch (Dali::DaliException e) {
89553       {
89554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89555       };
89556     } catch (...) {
89557       {
89558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89559       };
89560     }
89561   }
89562
89563   jresult = (void *)result;
89564   return jresult;
89565 }
89566
89567
89568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89569   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89570
89571   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89572   {
89573     try {
89574       delete arg1;
89575     } catch (std::out_of_range& e) {
89576       {
89577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89578       };
89579     } catch (std::exception& e) {
89580       {
89581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89582       };
89583     } catch (Dali::DaliException e) {
89584       {
89585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89586       };
89587     } catch (...) {
89588       {
89589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89590       };
89591     }
89592   }
89593
89594 }
89595
89596
89597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89598   void * jresult ;
89599   Dali::Toolkit::PageTurnView *result = 0 ;
89600
89601   {
89602     try {
89603       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89604     } catch (std::out_of_range& e) {
89605       {
89606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89607       };
89608     } catch (std::exception& e) {
89609       {
89610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89611       };
89612     } catch (Dali::DaliException e) {
89613       {
89614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89615       };
89616     } catch (...) {
89617       {
89618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89619       };
89620     }
89621   }
89622
89623   jresult = (void *)result;
89624   return jresult;
89625 }
89626
89627
89628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89629   void * jresult ;
89630   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89631   Dali::Toolkit::PageTurnView *result = 0 ;
89632
89633   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89634   if (!arg1) {
89635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89636     return 0;
89637   }
89638   {
89639     try {
89640       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89641     } catch (std::out_of_range& e) {
89642       {
89643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89644       };
89645     } catch (std::exception& e) {
89646       {
89647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89648       };
89649     } catch (Dali::DaliException e) {
89650       {
89651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89652       };
89653     } catch (...) {
89654       {
89655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89656       };
89657     }
89658   }
89659
89660   jresult = (void *)result;
89661   return jresult;
89662 }
89663
89664
89665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89666   void * jresult ;
89667   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89668   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89669   Dali::Toolkit::PageTurnView *result = 0 ;
89670
89671   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89672   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89673   if (!arg2) {
89674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89675     return 0;
89676   }
89677   {
89678     try {
89679       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89680     } catch (std::out_of_range& e) {
89681       {
89682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89683       };
89684     } catch (std::exception& e) {
89685       {
89686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89687       };
89688     } catch (Dali::DaliException e) {
89689       {
89690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89691       };
89692     } catch (...) {
89693       {
89694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89695       };
89696     }
89697   }
89698
89699   jresult = (void *)result;
89700   return jresult;
89701 }
89702
89703
89704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89705   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89706
89707   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89708   {
89709     try {
89710       delete arg1;
89711     } catch (std::out_of_range& e) {
89712       {
89713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89714       };
89715     } catch (std::exception& e) {
89716       {
89717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89718       };
89719     } catch (Dali::DaliException e) {
89720       {
89721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89722       };
89723     } catch (...) {
89724       {
89725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89726       };
89727     }
89728   }
89729
89730 }
89731
89732
89733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89734   void * jresult ;
89735   Dali::BaseHandle arg1 ;
89736   Dali::BaseHandle *argp1 ;
89737   Dali::Toolkit::PageTurnView result;
89738
89739   argp1 = (Dali::BaseHandle *)jarg1;
89740   if (!argp1) {
89741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89742     return 0;
89743   }
89744   arg1 = *argp1;
89745   {
89746     try {
89747       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89748     } catch (std::out_of_range& e) {
89749       {
89750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89751       };
89752     } catch (std::exception& e) {
89753       {
89754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89755       };
89756     } catch (Dali::DaliException e) {
89757       {
89758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89759       };
89760     } catch (...) {
89761       {
89762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89763       };
89764     }
89765   }
89766
89767   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89768   return jresult;
89769 }
89770
89771
89772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89773   void * jresult ;
89774   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89775   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89776
89777   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89778   {
89779     try {
89780       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89781     } catch (std::out_of_range& e) {
89782       {
89783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89784       };
89785     } catch (std::exception& e) {
89786       {
89787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89788       };
89789     } catch (Dali::DaliException e) {
89790       {
89791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89792       };
89793     } catch (...) {
89794       {
89795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89796       };
89797     }
89798   }
89799
89800   jresult = (void *)result;
89801   return jresult;
89802 }
89803
89804
89805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89806   void * jresult ;
89807   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89808   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89809
89810   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89811   {
89812     try {
89813       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89814     } catch (std::out_of_range& e) {
89815       {
89816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89817       };
89818     } catch (std::exception& e) {
89819       {
89820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89821       };
89822     } catch (Dali::DaliException e) {
89823       {
89824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89825       };
89826     } catch (...) {
89827       {
89828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89829       };
89830     }
89831   }
89832
89833   jresult = (void *)result;
89834   return jresult;
89835 }
89836
89837
89838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89839   void * jresult ;
89840   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89841   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89842
89843   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89844   {
89845     try {
89846       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89847     } catch (std::out_of_range& e) {
89848       {
89849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89850       };
89851     } catch (std::exception& e) {
89852       {
89853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89854       };
89855     } catch (Dali::DaliException e) {
89856       {
89857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89858       };
89859     } catch (...) {
89860       {
89861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89862       };
89863     }
89864   }
89865
89866   jresult = (void *)result;
89867   return jresult;
89868 }
89869
89870
89871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89872   void * jresult ;
89873   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89874   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89875
89876   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89877   {
89878     try {
89879       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89880     } catch (std::out_of_range& e) {
89881       {
89882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89883       };
89884     } catch (std::exception& e) {
89885       {
89886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89887       };
89888     } catch (Dali::DaliException e) {
89889       {
89890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89891       };
89892     } catch (...) {
89893       {
89894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89895       };
89896     }
89897   }
89898
89899   jresult = (void *)result;
89900   return jresult;
89901 }
89902
89903
89904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89905   void * jresult ;
89906   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89907
89908   {
89909     try {
89910       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89911     } catch (std::out_of_range& e) {
89912       {
89913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89914       };
89915     } catch (std::exception& e) {
89916       {
89917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89918       };
89919     } catch (Dali::DaliException e) {
89920       {
89921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89922       };
89923     } catch (...) {
89924       {
89925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89926       };
89927     }
89928   }
89929
89930   jresult = (void *)result;
89931   return jresult;
89932 }
89933
89934
89935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89936   void * jresult ;
89937   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89938   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89939
89940   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89941   if (!arg1) {
89942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89943     return 0;
89944   }
89945   {
89946     try {
89947       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89948     } catch (std::out_of_range& e) {
89949       {
89950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89951       };
89952     } catch (std::exception& e) {
89953       {
89954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89955       };
89956     } catch (Dali::DaliException e) {
89957       {
89958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89959       };
89960     } catch (...) {
89961       {
89962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89963       };
89964     }
89965   }
89966
89967   jresult = (void *)result;
89968   return jresult;
89969 }
89970
89971
89972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89973   void * jresult ;
89974   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89975   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89976   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89977
89978   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89979   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89980   if (!arg2) {
89981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89982     return 0;
89983   }
89984   {
89985     try {
89986       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89987     } catch (std::out_of_range& e) {
89988       {
89989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89990       };
89991     } catch (std::exception& e) {
89992       {
89993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89994       };
89995     } catch (Dali::DaliException e) {
89996       {
89997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89998       };
89999     } catch (...) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90002       };
90003     }
90004   }
90005
90006   jresult = (void *)result;
90007   return jresult;
90008 }
90009
90010
90011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90012   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90013
90014   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90015   {
90016     try {
90017       delete arg1;
90018     } catch (std::out_of_range& e) {
90019       {
90020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90021       };
90022     } catch (std::exception& e) {
90023       {
90024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90025       };
90026     } catch (Dali::DaliException e) {
90027       {
90028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90029       };
90030     } catch (...) {
90031       {
90032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90033       };
90034     }
90035   }
90036
90037 }
90038
90039
90040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90041   void * jresult ;
90042   Dali::Toolkit::PageFactory *arg1 = 0 ;
90043   Dali::Vector2 *arg2 = 0 ;
90044   Dali::Toolkit::PageTurnLandscapeView result;
90045
90046   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90047   if (!arg1) {
90048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90049     return 0;
90050   }
90051   arg2 = (Dali::Vector2 *)jarg2;
90052   if (!arg2) {
90053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90054     return 0;
90055   }
90056   {
90057     try {
90058       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90059     } catch (std::out_of_range& e) {
90060       {
90061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90062       };
90063     } catch (std::exception& e) {
90064       {
90065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90066       };
90067     } catch (Dali::DaliException e) {
90068       {
90069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90070       };
90071     } catch (...) {
90072       {
90073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90074       };
90075     }
90076   }
90077
90078   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90079   return jresult;
90080 }
90081
90082
90083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90084   void * jresult ;
90085   Dali::BaseHandle arg1 ;
90086   Dali::BaseHandle *argp1 ;
90087   Dali::Toolkit::PageTurnLandscapeView result;
90088
90089   argp1 = (Dali::BaseHandle *)jarg1;
90090   if (!argp1) {
90091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90092     return 0;
90093   }
90094   arg1 = *argp1;
90095   {
90096     try {
90097       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90098     } catch (std::out_of_range& e) {
90099       {
90100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90101       };
90102     } catch (std::exception& e) {
90103       {
90104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90105       };
90106     } catch (Dali::DaliException e) {
90107       {
90108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90109       };
90110     } catch (...) {
90111       {
90112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90113       };
90114     }
90115   }
90116
90117   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90118   return jresult;
90119 }
90120
90121
90122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90123   void * jresult ;
90124   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90125
90126   {
90127     try {
90128       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90129     } catch (std::out_of_range& e) {
90130       {
90131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90132       };
90133     } catch (std::exception& e) {
90134       {
90135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90136       };
90137     } catch (Dali::DaliException e) {
90138       {
90139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90140       };
90141     } catch (...) {
90142       {
90143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90144       };
90145     }
90146   }
90147
90148   jresult = (void *)result;
90149   return jresult;
90150 }
90151
90152
90153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90154   void * jresult ;
90155   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90156   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90157
90158   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90159   if (!arg1) {
90160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90161     return 0;
90162   }
90163   {
90164     try {
90165       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90166     } catch (std::out_of_range& e) {
90167       {
90168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90169       };
90170     } catch (std::exception& e) {
90171       {
90172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90173       };
90174     } catch (Dali::DaliException e) {
90175       {
90176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90177       };
90178     } catch (...) {
90179       {
90180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90181       };
90182     }
90183   }
90184
90185   jresult = (void *)result;
90186   return jresult;
90187 }
90188
90189
90190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90191   void * jresult ;
90192   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90193   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90194   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90195
90196   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90197   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90198   if (!arg2) {
90199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90200     return 0;
90201   }
90202   {
90203     try {
90204       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90205     } catch (std::out_of_range& e) {
90206       {
90207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90208       };
90209     } catch (std::exception& e) {
90210       {
90211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90212       };
90213     } catch (Dali::DaliException e) {
90214       {
90215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90216       };
90217     } catch (...) {
90218       {
90219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90220       };
90221     }
90222   }
90223
90224   jresult = (void *)result;
90225   return jresult;
90226 }
90227
90228
90229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90230   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90231
90232   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90233   {
90234     try {
90235       delete arg1;
90236     } catch (std::out_of_range& e) {
90237       {
90238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90239       };
90240     } catch (std::exception& e) {
90241       {
90242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90243       };
90244     } catch (Dali::DaliException e) {
90245       {
90246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90247       };
90248     } catch (...) {
90249       {
90250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90251       };
90252     }
90253   }
90254
90255 }
90256
90257
90258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90259   void * jresult ;
90260   Dali::Toolkit::PageFactory *arg1 = 0 ;
90261   Dali::Vector2 *arg2 = 0 ;
90262   Dali::Toolkit::PageTurnPortraitView result;
90263
90264   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90265   if (!arg1) {
90266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90267     return 0;
90268   }
90269   arg2 = (Dali::Vector2 *)jarg2;
90270   if (!arg2) {
90271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90272     return 0;
90273   }
90274   {
90275     try {
90276       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90277     } catch (std::out_of_range& e) {
90278       {
90279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90280       };
90281     } catch (std::exception& e) {
90282       {
90283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90284       };
90285     } catch (Dali::DaliException e) {
90286       {
90287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90288       };
90289     } catch (...) {
90290       {
90291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90292       };
90293     }
90294   }
90295
90296   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90297   return jresult;
90298 }
90299
90300
90301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90302   void * jresult ;
90303   Dali::BaseHandle arg1 ;
90304   Dali::BaseHandle *argp1 ;
90305   Dali::Toolkit::PageTurnPortraitView result;
90306
90307   argp1 = (Dali::BaseHandle *)jarg1;
90308   if (!argp1) {
90309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90310     return 0;
90311   }
90312   arg1 = *argp1;
90313   {
90314     try {
90315       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90316     } catch (std::out_of_range& e) {
90317       {
90318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90319       };
90320     } catch (std::exception& e) {
90321       {
90322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90323       };
90324     } catch (Dali::DaliException e) {
90325       {
90326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90327       };
90328     } catch (...) {
90329       {
90330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90331       };
90332     }
90333   }
90334
90335   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90336   return jresult;
90337 }
90338
90339
90340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90341   int jresult ;
90342   int result;
90343
90344   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90345   jresult = (int)result;
90346   return jresult;
90347 }
90348
90349
90350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90351   int jresult ;
90352   int result;
90353
90354   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90355   jresult = (int)result;
90356   return jresult;
90357 }
90358
90359
90360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90361   int jresult ;
90362   int result;
90363
90364   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90365   jresult = (int)result;
90366   return jresult;
90367 }
90368
90369
90370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90371   void * jresult ;
90372   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90373
90374   {
90375     try {
90376       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90377     } catch (std::out_of_range& e) {
90378       {
90379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90380       };
90381     } catch (std::exception& e) {
90382       {
90383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90384       };
90385     } catch (Dali::DaliException e) {
90386       {
90387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90388       };
90389     } catch (...) {
90390       {
90391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90392       };
90393     }
90394   }
90395
90396   jresult = (void *)result;
90397   return jresult;
90398 }
90399
90400
90401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90402   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90403
90404   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90405   {
90406     try {
90407       delete arg1;
90408     } catch (std::out_of_range& e) {
90409       {
90410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90411       };
90412     } catch (std::exception& e) {
90413       {
90414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90415       };
90416     } catch (Dali::DaliException e) {
90417       {
90418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90419       };
90420     } catch (...) {
90421       {
90422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90423       };
90424     }
90425   }
90426
90427 }
90428
90429
90430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90431   void * jresult ;
90432   Dali::Toolkit::ToggleButton *result = 0 ;
90433
90434   {
90435     try {
90436       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90437     } catch (std::out_of_range& e) {
90438       {
90439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90440       };
90441     } catch (std::exception& e) {
90442       {
90443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90444       };
90445     } catch (Dali::DaliException e) {
90446       {
90447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90448       };
90449     } catch (...) {
90450       {
90451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90452       };
90453     }
90454   }
90455
90456   jresult = (void *)result;
90457   return jresult;
90458 }
90459
90460
90461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90462   void * jresult ;
90463   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90464   Dali::Toolkit::ToggleButton *result = 0 ;
90465
90466   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90467   if (!arg1) {
90468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90469     return 0;
90470   }
90471   {
90472     try {
90473       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90474     } catch (std::out_of_range& e) {
90475       {
90476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90477       };
90478     } catch (std::exception& e) {
90479       {
90480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90481       };
90482     } catch (Dali::DaliException e) {
90483       {
90484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90485       };
90486     } catch (...) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90489       };
90490     }
90491   }
90492
90493   jresult = (void *)result;
90494   return jresult;
90495 }
90496
90497
90498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90499   void * jresult ;
90500   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90501   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90502   Dali::Toolkit::ToggleButton *result = 0 ;
90503
90504   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90505   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90506   if (!arg2) {
90507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90508     return 0;
90509   }
90510   {
90511     try {
90512       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90513     } catch (std::out_of_range& e) {
90514       {
90515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90516       };
90517     } catch (std::exception& e) {
90518       {
90519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90520       };
90521     } catch (Dali::DaliException e) {
90522       {
90523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90524       };
90525     } catch (...) {
90526       {
90527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90528       };
90529     }
90530   }
90531
90532   jresult = (void *)result;
90533   return jresult;
90534 }
90535
90536
90537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90538   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90539
90540   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90541   {
90542     try {
90543       delete arg1;
90544     } catch (std::out_of_range& e) {
90545       {
90546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90547       };
90548     } catch (std::exception& e) {
90549       {
90550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90551       };
90552     } catch (Dali::DaliException e) {
90553       {
90554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90555       };
90556     } catch (...) {
90557       {
90558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90559       };
90560     }
90561   }
90562
90563 }
90564
90565
90566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90567   void * jresult ;
90568   Dali::Toolkit::ToggleButton result;
90569
90570   {
90571     try {
90572       result = Dali::Toolkit::ToggleButton::New();
90573     } catch (std::out_of_range& e) {
90574       {
90575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90576       };
90577     } catch (std::exception& e) {
90578       {
90579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90580       };
90581     } catch (Dali::DaliException e) {
90582       {
90583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90584       };
90585     } catch (...) {
90586       {
90587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90588       };
90589     }
90590   }
90591
90592   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90593   return jresult;
90594 }
90595
90596
90597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90598   void * jresult ;
90599   Dali::BaseHandle arg1 ;
90600   Dali::BaseHandle *argp1 ;
90601   Dali::Toolkit::ToggleButton result;
90602
90603   argp1 = (Dali::BaseHandle *)jarg1;
90604   if (!argp1) {
90605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90606     return 0;
90607   }
90608   arg1 = *argp1;
90609   {
90610     try {
90611       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90612     } catch (std::out_of_range& e) {
90613       {
90614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90615       };
90616     } catch (std::exception& e) {
90617       {
90618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90619       };
90620     } catch (Dali::DaliException e) {
90621       {
90622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90623       };
90624     } catch (...) {
90625       {
90626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90627       };
90628     }
90629   }
90630
90631   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90632   return jresult;
90633 }
90634
90635
90636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90637   void * jresult ;
90638   Dali::Toolkit::Visual::Base *result = 0 ;
90639
90640   {
90641     try {
90642       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90643     } catch (std::out_of_range& e) {
90644       {
90645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90646       };
90647     } catch (std::exception& e) {
90648       {
90649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90650       };
90651     } catch (Dali::DaliException e) {
90652       {
90653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90654       };
90655     } catch (...) {
90656       {
90657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90658       };
90659     }
90660   }
90661
90662   jresult = (void *)result;
90663   return jresult;
90664 }
90665
90666
90667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90668   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90669
90670   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90671   {
90672     try {
90673       delete arg1;
90674     } catch (std::out_of_range& e) {
90675       {
90676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90677       };
90678     } catch (std::exception& e) {
90679       {
90680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90681       };
90682     } catch (Dali::DaliException e) {
90683       {
90684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90685       };
90686     } catch (...) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90689       };
90690     }
90691   }
90692
90693 }
90694
90695
90696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90697   void * jresult ;
90698   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90699   Dali::Toolkit::Visual::Base *result = 0 ;
90700
90701   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90702   if (!arg1) {
90703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90704     return 0;
90705   }
90706   {
90707     try {
90708       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90709     } catch (std::out_of_range& e) {
90710       {
90711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90712       };
90713     } catch (std::exception& e) {
90714       {
90715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90716       };
90717     } catch (Dali::DaliException e) {
90718       {
90719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90720       };
90721     } catch (...) {
90722       {
90723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90724       };
90725     }
90726   }
90727
90728   jresult = (void *)result;
90729   return jresult;
90730 }
90731
90732
90733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90734   void * jresult ;
90735   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90736   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90737   Dali::Toolkit::Visual::Base *result = 0 ;
90738
90739   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90740   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90741   if (!arg2) {
90742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90743     return 0;
90744   }
90745   {
90746     try {
90747       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90748     } catch (std::out_of_range& e) {
90749       {
90750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90751       };
90752     } catch (std::exception& e) {
90753       {
90754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90755       };
90756     } catch (Dali::DaliException e) {
90757       {
90758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90759       };
90760     } catch (...) {
90761       {
90762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90763       };
90764     }
90765   }
90766
90767   jresult = (void *)result;
90768   return jresult;
90769 }
90770
90771
90772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90773   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90774   std::string *arg2 = 0 ;
90775
90776   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90777   if (!jarg2) {
90778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90779     return ;
90780   }
90781   std::string arg2_str(jarg2);
90782   arg2 = &arg2_str;
90783   {
90784     try {
90785       (arg1)->SetName((std::string const &)*arg2);
90786     } catch (std::out_of_range& e) {
90787       {
90788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90789       };
90790     } catch (std::exception& e) {
90791       {
90792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90793       };
90794     } catch (Dali::DaliException e) {
90795       {
90796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90797       };
90798     } catch (...) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90801       };
90802     }
90803   }
90804
90805
90806   //argout typemap for const std::string&
90807
90808 }
90809
90810
90811 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90812   char * jresult ;
90813   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90814   std::string *result = 0 ;
90815
90816   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90817   {
90818     try {
90819       result = (std::string *) &(arg1)->GetName();
90820     } catch (std::out_of_range& e) {
90821       {
90822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90823       };
90824     } catch (std::exception& e) {
90825       {
90826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90827       };
90828     } catch (Dali::DaliException e) {
90829       {
90830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90831       };
90832     } catch (...) {
90833       {
90834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90835       };
90836     }
90837   }
90838
90839   jresult = SWIG_csharp_string_callback(result->c_str());
90840   return jresult;
90841 }
90842
90843
90844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90845   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90846   Dali::Property::Map *arg2 = 0 ;
90847   Dali::Size arg3 ;
90848   Dali::Size *argp3 ;
90849
90850   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90851   arg2 = (Dali::Property::Map *)jarg2;
90852   if (!arg2) {
90853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90854     return ;
90855   }
90856   argp3 = (Dali::Size *)jarg3;
90857   if (!argp3) {
90858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90859     return ;
90860   }
90861   arg3 = *argp3;
90862   {
90863     try {
90864       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90865     } catch (std::out_of_range& e) {
90866       {
90867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90868       };
90869     } catch (std::exception& e) {
90870       {
90871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90872       };
90873     } catch (Dali::DaliException e) {
90874       {
90875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90876       };
90877     } catch (...) {
90878       {
90879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90880       };
90881     }
90882   }
90883
90884 }
90885
90886
90887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90888   float jresult ;
90889   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90890   float arg2 ;
90891   float result;
90892
90893   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90894   arg2 = (float)jarg2;
90895   {
90896     try {
90897       result = (float)(arg1)->GetHeightForWidth(arg2);
90898     } catch (std::out_of_range& e) {
90899       {
90900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90901       };
90902     } catch (std::exception& e) {
90903       {
90904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90905       };
90906     } catch (Dali::DaliException e) {
90907       {
90908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90909       };
90910     } catch (...) {
90911       {
90912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90913       };
90914     }
90915   }
90916
90917   jresult = result;
90918   return jresult;
90919 }
90920
90921
90922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90923   float jresult ;
90924   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90925   float arg2 ;
90926   float result;
90927
90928   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90929   arg2 = (float)jarg2;
90930   {
90931     try {
90932       result = (float)(arg1)->GetWidthForHeight(arg2);
90933     } catch (std::out_of_range& e) {
90934       {
90935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90936       };
90937     } catch (std::exception& e) {
90938       {
90939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90940       };
90941     } catch (Dali::DaliException e) {
90942       {
90943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90944       };
90945     } catch (...) {
90946       {
90947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90948       };
90949     }
90950   }
90951
90952   jresult = result;
90953   return jresult;
90954 }
90955
90956
90957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90958   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90959   Dali::Vector2 *arg2 = 0 ;
90960
90961   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90962   arg2 = (Dali::Vector2 *)jarg2;
90963   if (!arg2) {
90964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90965     return ;
90966   }
90967   {
90968     try {
90969       (arg1)->GetNaturalSize(*arg2);
90970     } catch (std::out_of_range& e) {
90971       {
90972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90973       };
90974     } catch (std::exception& e) {
90975       {
90976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90977       };
90978     } catch (Dali::DaliException e) {
90979       {
90980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90981       };
90982     } catch (...) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90985       };
90986     }
90987   }
90988
90989 }
90990
90991
90992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90993   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90994   float arg2 ;
90995
90996   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90997   arg2 = (int)jarg2;
90998   {
90999     try {
91000       (arg1)->SetDepthIndex(arg2);
91001     } catch (std::out_of_range& e) {
91002       {
91003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91004       };
91005     } catch (std::exception& e) {
91006       {
91007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91008       };
91009     } catch (Dali::DaliException e) {
91010       {
91011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91012       };
91013     } catch (...) {
91014       {
91015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91016       };
91017     }
91018   }
91019
91020 }
91021
91022
91023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91024   int jresult ;
91025   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91026   int result;
91027
91028   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91029   {
91030     try {
91031       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91032     } catch (std::out_of_range& e) {
91033       {
91034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91035       };
91036     } catch (std::exception& e) {
91037       {
91038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91039       };
91040     } catch (Dali::DaliException e) {
91041       {
91042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91043       };
91044     } catch (...) {
91045       {
91046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91047       };
91048     }
91049   }
91050
91051   jresult = result;
91052   return jresult;
91053 }
91054
91055
91056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91057   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91058   Dali::Property::Map *arg2 = 0 ;
91059
91060   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91061   arg2 = (Dali::Property::Map *)jarg2;
91062   if (!arg2) {
91063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91064     return ;
91065   }
91066   {
91067     try {
91068       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91069     } catch (std::out_of_range& e) {
91070       {
91071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91072       };
91073     } catch (std::exception& e) {
91074       {
91075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91076       };
91077     } catch (Dali::DaliException e) {
91078       {
91079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91080       };
91081     } catch (...) {
91082       {
91083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91084       };
91085     }
91086   }
91087
91088 }
91089
91090
91091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91092   void * jresult ;
91093   Dali::Toolkit::VisualFactory result;
91094
91095   {
91096     try {
91097       result = Dali::Toolkit::VisualFactory::Get();
91098     } catch (std::out_of_range& e) {
91099       {
91100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91101       };
91102     } catch (std::exception& e) {
91103       {
91104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91105       };
91106     } catch (Dali::DaliException e) {
91107       {
91108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91109       };
91110     } catch (...) {
91111       {
91112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91113       };
91114     }
91115   }
91116
91117   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91118   return jresult;
91119 }
91120
91121
91122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91123   void * jresult ;
91124   Dali::Toolkit::VisualFactory *result = 0 ;
91125
91126   {
91127     try {
91128       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91129     } catch (std::out_of_range& e) {
91130       {
91131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91132       };
91133     } catch (std::exception& e) {
91134       {
91135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91136       };
91137     } catch (Dali::DaliException e) {
91138       {
91139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91140       };
91141     } catch (...) {
91142       {
91143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91144       };
91145     }
91146   }
91147
91148   jresult = (void *)result;
91149   return jresult;
91150 }
91151
91152
91153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91154   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91155
91156   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91157   {
91158     try {
91159       delete arg1;
91160     } catch (std::out_of_range& e) {
91161       {
91162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91163       };
91164     } catch (std::exception& e) {
91165       {
91166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91167       };
91168     } catch (Dali::DaliException e) {
91169       {
91170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91171       };
91172     } catch (...) {
91173       {
91174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91175       };
91176     }
91177   }
91178
91179 }
91180
91181
91182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91183   void * jresult ;
91184   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91185   Dali::Toolkit::VisualFactory *result = 0 ;
91186
91187   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91188   if (!arg1) {
91189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91190     return 0;
91191   }
91192   {
91193     try {
91194       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91195     } catch (std::out_of_range& e) {
91196       {
91197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91198       };
91199     } catch (std::exception& e) {
91200       {
91201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91202       };
91203     } catch (Dali::DaliException e) {
91204       {
91205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91206       };
91207     } catch (...) {
91208       {
91209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91210       };
91211     }
91212   }
91213
91214   jresult = (void *)result;
91215   return jresult;
91216 }
91217
91218
91219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91220   void * jresult ;
91221   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91222   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91223   Dali::Toolkit::VisualFactory *result = 0 ;
91224
91225   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91226   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91227   if (!arg2) {
91228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91229     return 0;
91230   }
91231   {
91232     try {
91233       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91234     } catch (std::out_of_range& e) {
91235       {
91236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91237       };
91238     } catch (std::exception& e) {
91239       {
91240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91241       };
91242     } catch (Dali::DaliException e) {
91243       {
91244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91245       };
91246     } catch (...) {
91247       {
91248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91249       };
91250     }
91251   }
91252
91253   jresult = (void *)result;
91254   return jresult;
91255 }
91256
91257
91258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91259   void * jresult ;
91260   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91261   Dali::Property::Map *arg2 = 0 ;
91262   Dali::Toolkit::Visual::Base result;
91263
91264   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91265   arg2 = (Dali::Property::Map *)jarg2;
91266   if (!arg2) {
91267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91268     return 0;
91269   }
91270   {
91271     try {
91272       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91273     } catch (std::out_of_range& e) {
91274       {
91275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91276       };
91277     } catch (std::exception& e) {
91278       {
91279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91280       };
91281     } catch (Dali::DaliException e) {
91282       {
91283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91284       };
91285     } catch (...) {
91286       {
91287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91288       };
91289     }
91290   }
91291
91292   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91293   return jresult;
91294 }
91295
91296
91297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91298   void * jresult ;
91299   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91300   Dali::Image *arg2 = 0 ;
91301   Dali::Toolkit::Visual::Base result;
91302
91303   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91304   arg2 = (Dali::Image *)jarg2;
91305   if (!arg2) {
91306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91307     return 0;
91308   }
91309   {
91310     try {
91311       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91312     } catch (std::out_of_range& e) {
91313       {
91314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91315       };
91316     } catch (std::exception& e) {
91317       {
91318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91319       };
91320     } catch (Dali::DaliException e) {
91321       {
91322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91323       };
91324     } catch (...) {
91325       {
91326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91327       };
91328     }
91329   }
91330
91331   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91332   return jresult;
91333 }
91334
91335
91336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91337   void * jresult ;
91338   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91339   std::string *arg2 = 0 ;
91340   Dali::ImageDimensions arg3 ;
91341   Dali::ImageDimensions *argp3 ;
91342   Dali::Toolkit::Visual::Base result;
91343
91344   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91345   if (!jarg2) {
91346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91347     return 0;
91348   }
91349   std::string arg2_str(jarg2);
91350   arg2 = &arg2_str;
91351   argp3 = (Dali::ImageDimensions *)jarg3;
91352   if (!argp3) {
91353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91354     return 0;
91355   }
91356   arg3 = *argp3;
91357   {
91358     try {
91359       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91360     } catch (std::out_of_range& e) {
91361       {
91362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91363       };
91364     } catch (std::exception& e) {
91365       {
91366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91367       };
91368     } catch (Dali::DaliException e) {
91369       {
91370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91371       };
91372     } catch (...) {
91373       {
91374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91375       };
91376     }
91377   }
91378
91379   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91380
91381   //argout typemap for const std::string&
91382
91383   return jresult;
91384 }
91385
91386
91387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91388   void * jresult ;
91389   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91390
91391   {
91392     try {
91393       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91394     } catch (std::out_of_range& e) {
91395       {
91396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91397       };
91398     } catch (std::exception& e) {
91399       {
91400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91401       };
91402     } catch (Dali::DaliException e) {
91403       {
91404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91405       };
91406     } catch (...) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91409       };
91410     }
91411   }
91412
91413   jresult = (void *)result;
91414   return jresult;
91415 }
91416
91417
91418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91419   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91420
91421   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91422   {
91423     try {
91424       delete arg1;
91425     } catch (std::out_of_range& e) {
91426       {
91427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91428       };
91429     } catch (std::exception& e) {
91430       {
91431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91432       };
91433     } catch (Dali::DaliException e) {
91434       {
91435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91436       };
91437     } catch (...) {
91438       {
91439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91440       };
91441     }
91442   }
91443
91444 }
91445
91446
91447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91448   void * jresult ;
91449   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91450   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91451
91452   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91453   if (!arg1) {
91454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91455     return 0;
91456   }
91457   {
91458     try {
91459       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91460     } catch (std::out_of_range& e) {
91461       {
91462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91463       };
91464     } catch (std::exception& e) {
91465       {
91466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91467       };
91468     } catch (Dali::DaliException e) {
91469       {
91470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91471       };
91472     } catch (...) {
91473       {
91474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91475       };
91476     }
91477   }
91478
91479   jresult = (void *)result;
91480   return jresult;
91481 }
91482
91483
91484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91485   void * jresult ;
91486   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91487   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91488   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91489
91490   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91491   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91492   if (!arg2) {
91493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91494     return 0;
91495   }
91496   {
91497     try {
91498       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91499     } catch (std::out_of_range& e) {
91500       {
91501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91502       };
91503     } catch (std::exception& e) {
91504       {
91505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91506       };
91507     } catch (Dali::DaliException e) {
91508       {
91509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91510       };
91511     } catch (...) {
91512       {
91513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91514       };
91515     }
91516   }
91517
91518   jresult = (void *)result;
91519   return jresult;
91520 }
91521
91522
91523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91524   void * jresult ;
91525   Dali::Toolkit::AsyncImageLoader result;
91526
91527   {
91528     try {
91529       result = Dali::Toolkit::AsyncImageLoader::New();
91530     } catch (std::out_of_range& e) {
91531       {
91532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91533       };
91534     } catch (std::exception& e) {
91535       {
91536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91537       };
91538     } catch (Dali::DaliException e) {
91539       {
91540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91541       };
91542     } catch (...) {
91543       {
91544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91545       };
91546     }
91547   }
91548
91549   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91550   return jresult;
91551 }
91552
91553
91554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91555   void * jresult ;
91556   Dali::BaseHandle arg1 ;
91557   Dali::BaseHandle *argp1 ;
91558   Dali::Toolkit::AsyncImageLoader result;
91559
91560   argp1 = (Dali::BaseHandle *)jarg1;
91561   if (!argp1) {
91562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91563     return 0;
91564   }
91565   arg1 = *argp1;
91566   {
91567     try {
91568       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91569     } catch (std::out_of_range& e) {
91570       {
91571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91572       };
91573     } catch (std::exception& e) {
91574       {
91575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91576       };
91577     } catch (Dali::DaliException e) {
91578       {
91579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91580       };
91581     } catch (...) {
91582       {
91583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91584       };
91585     }
91586   }
91587
91588   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91589   return jresult;
91590 }
91591
91592
91593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91594   unsigned int jresult ;
91595   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91596   std::string *arg2 = 0 ;
91597   uint32_t result;
91598
91599   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91600   if (!jarg2) {
91601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91602     return 0;
91603   }
91604   std::string arg2_str(jarg2);
91605   arg2 = &arg2_str;
91606   {
91607     try {
91608       result = (arg1)->Load((std::string const &)*arg2);
91609     } catch (std::out_of_range& e) {
91610       {
91611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91612       };
91613     } catch (std::exception& e) {
91614       {
91615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91616       };
91617     } catch (Dali::DaliException e) {
91618       {
91619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91620       };
91621     } catch (...) {
91622       {
91623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91624       };
91625     }
91626   }
91627
91628   jresult = result;
91629
91630   //argout typemap for const std::string&
91631
91632   return jresult;
91633 }
91634
91635
91636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91637   unsigned int jresult ;
91638   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91639   std::string *arg2 = 0 ;
91640   Dali::ImageDimensions arg3 ;
91641   Dali::ImageDimensions *argp3 ;
91642   uint32_t result;
91643
91644   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91645   if (!jarg2) {
91646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91647     return 0;
91648   }
91649   std::string arg2_str(jarg2);
91650   arg2 = &arg2_str;
91651   argp3 = (Dali::ImageDimensions *)jarg3;
91652   if (!argp3) {
91653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91654     return 0;
91655   }
91656   arg3 = *argp3;
91657   {
91658     try {
91659       result = (arg1)->Load((std::string const &)*arg2,arg3);
91660     } catch (std::out_of_range& e) {
91661       {
91662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91663       };
91664     } catch (std::exception& e) {
91665       {
91666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91667       };
91668     } catch (Dali::DaliException e) {
91669       {
91670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91671       };
91672     } catch (...) {
91673       {
91674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91675       };
91676     }
91677   }
91678
91679   jresult = result;
91680
91681   //argout typemap for const std::string&
91682
91683   return jresult;
91684 }
91685
91686
91687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91688   unsigned int jresult ;
91689   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91690   std::string *arg2 = 0 ;
91691   Dali::ImageDimensions arg3 ;
91692   Dali::FittingMode::Type arg4 ;
91693   Dali::SamplingMode::Type arg5 ;
91694   bool arg6 ;
91695   Dali::ImageDimensions *argp3 ;
91696   uint32_t result;
91697
91698   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91699   if (!jarg2) {
91700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91701     return 0;
91702   }
91703   std::string arg2_str(jarg2);
91704   arg2 = &arg2_str;
91705   argp3 = (Dali::ImageDimensions *)jarg3;
91706   if (!argp3) {
91707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91708     return 0;
91709   }
91710   arg3 = *argp3;
91711   arg4 = (Dali::FittingMode::Type)jarg4;
91712   arg5 = (Dali::SamplingMode::Type)jarg5;
91713   arg6 = jarg6 ? true : false;
91714   {
91715     try {
91716       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91717     } catch (std::out_of_range& e) {
91718       {
91719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91720       };
91721     } catch (std::exception& e) {
91722       {
91723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91724       };
91725     } catch (Dali::DaliException e) {
91726       {
91727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91728       };
91729     } catch (...) {
91730       {
91731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91732       };
91733     }
91734   }
91735
91736   jresult = result;
91737
91738   //argout typemap for const std::string&
91739
91740   return jresult;
91741 }
91742
91743
91744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91745   unsigned int jresult ;
91746   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91747   uint32_t arg2 ;
91748   bool result;
91749
91750   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91751   arg2 = (uint32_t)jarg2;
91752   {
91753     try {
91754       result = (bool)(arg1)->Cancel(arg2);
91755     } catch (std::out_of_range& e) {
91756       {
91757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91758       };
91759     } catch (std::exception& e) {
91760       {
91761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91762       };
91763     } catch (Dali::DaliException e) {
91764       {
91765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91766       };
91767     } catch (...) {
91768       {
91769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91770       };
91771     }
91772   }
91773
91774   jresult = result;
91775   return jresult;
91776 }
91777
91778
91779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91780   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91781
91782   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91783   {
91784     try {
91785       (arg1)->CancelAll();
91786     } catch (std::out_of_range& e) {
91787       {
91788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91789       };
91790     } catch (std::exception& e) {
91791       {
91792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91793       };
91794     } catch (Dali::DaliException e) {
91795       {
91796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91797       };
91798     } catch (...) {
91799       {
91800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91801       };
91802     }
91803   }
91804
91805 }
91806
91807
91808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91809   void * jresult ;
91810   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91811   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91812
91813   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91814   {
91815     try {
91816       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91817     } catch (std::out_of_range& e) {
91818       {
91819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91820       };
91821     } catch (std::exception& e) {
91822       {
91823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91824       };
91825     } catch (Dali::DaliException e) {
91826       {
91827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91828       };
91829     } catch (...) {
91830       {
91831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91832       };
91833     }
91834   }
91835
91836   jresult = (void *)result;
91837   return jresult;
91838 }
91839
91840
91841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91842   void * jresult ;
91843   std::string *arg1 = 0 ;
91844   Dali::PixelData result;
91845
91846   if (!jarg1) {
91847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91848     return 0;
91849   }
91850   std::string arg1_str(jarg1);
91851   arg1 = &arg1_str;
91852   {
91853     try {
91854       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91855     } catch (std::out_of_range& e) {
91856       {
91857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91858       };
91859     } catch (std::exception& e) {
91860       {
91861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91862       };
91863     } catch (Dali::DaliException e) {
91864       {
91865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91866       };
91867     } catch (...) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91870       };
91871     }
91872   }
91873
91874   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91875
91876   //argout typemap for const std::string&
91877
91878   return jresult;
91879 }
91880
91881
91882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91883   void * jresult ;
91884   std::string *arg1 = 0 ;
91885   Dali::ImageDimensions arg2 ;
91886   Dali::ImageDimensions *argp2 ;
91887   Dali::PixelData result;
91888
91889   if (!jarg1) {
91890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91891     return 0;
91892   }
91893   std::string arg1_str(jarg1);
91894   arg1 = &arg1_str;
91895   argp2 = (Dali::ImageDimensions *)jarg2;
91896   if (!argp2) {
91897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91898     return 0;
91899   }
91900   arg2 = *argp2;
91901   {
91902     try {
91903       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91904     } catch (std::out_of_range& e) {
91905       {
91906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91907       };
91908     } catch (std::exception& e) {
91909       {
91910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91911       };
91912     } catch (Dali::DaliException e) {
91913       {
91914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91915       };
91916     } catch (...) {
91917       {
91918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91919       };
91920     }
91921   }
91922
91923   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91924
91925   //argout typemap for const std::string&
91926
91927   return jresult;
91928 }
91929
91930
91931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91932   void * jresult ;
91933   std::string *arg1 = 0 ;
91934   Dali::ImageDimensions arg2 ;
91935   Dali::FittingMode::Type arg3 ;
91936   Dali::SamplingMode::Type arg4 ;
91937   bool arg5 ;
91938   Dali::ImageDimensions *argp2 ;
91939   Dali::PixelData result;
91940
91941   if (!jarg1) {
91942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91943     return 0;
91944   }
91945   std::string arg1_str(jarg1);
91946   arg1 = &arg1_str;
91947   argp2 = (Dali::ImageDimensions *)jarg2;
91948   if (!argp2) {
91949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91950     return 0;
91951   }
91952   arg2 = *argp2;
91953   arg3 = (Dali::FittingMode::Type)jarg3;
91954   arg4 = (Dali::SamplingMode::Type)jarg4;
91955   arg5 = jarg5 ? true : false;
91956   {
91957     try {
91958       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91959     } catch (std::out_of_range& e) {
91960       {
91961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91962       };
91963     } catch (std::exception& e) {
91964       {
91965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91966       };
91967     } catch (Dali::DaliException e) {
91968       {
91969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91970       };
91971     } catch (...) {
91972       {
91973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91974       };
91975     }
91976   }
91977
91978   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91979
91980   //argout typemap for const std::string&
91981
91982   return jresult;
91983 }
91984
91985
91986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91987   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91988
91989   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91990   {
91991     try {
91992       delete arg1;
91993     } catch (std::out_of_range& e) {
91994       {
91995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91996       };
91997     } catch (std::exception& e) {
91998       {
91999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92000       };
92001     } catch (Dali::DaliException e) {
92002       {
92003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92004       };
92005     } catch (...) {
92006       {
92007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92008       };
92009     }
92010   }
92011
92012 }
92013
92014
92015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92016   void * jresult ;
92017   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92018   Dali::Actor arg2 ;
92019   Dali::Actor arg3 ;
92020   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92021   Dali::Actor *argp2 ;
92022   Dali::Actor *argp3 ;
92023   Dali::Actor result;
92024
92025   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92026   argp2 = (Dali::Actor *)jarg2;
92027   if (!argp2) {
92028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92029     return 0;
92030   }
92031   arg2 = *argp2;
92032   argp3 = (Dali::Actor *)jarg3;
92033   if (!argp3) {
92034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92035     return 0;
92036   }
92037   arg3 = *argp3;
92038   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92039   {
92040     try {
92041       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92042     } catch (std::out_of_range& e) {
92043       {
92044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92045       };
92046     } catch (std::exception& e) {
92047       {
92048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92049       };
92050     } catch (Dali::DaliException e) {
92051       {
92052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92053       };
92054     } catch (...) {
92055       {
92056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92057       };
92058     }
92059   }
92060
92061   jresult = new Dali::Actor((const Dali::Actor &)result);
92062   return jresult;
92063 }
92064
92065
92066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92067   void * jresult ;
92068   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92069
92070   {
92071     try {
92072       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92073     } catch (std::out_of_range& e) {
92074       {
92075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92076       };
92077     } catch (std::exception& e) {
92078       {
92079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92080       };
92081     } catch (Dali::DaliException e) {
92082       {
92083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92084       };
92085     } catch (...) {
92086       {
92087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92088       };
92089     }
92090   }
92091
92092   jresult = (void *)result;
92093   return jresult;
92094 }
92095
92096
92097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92098   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92099   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92100   if (director) {
92101     director->swig_connect_director(callback0);
92102   }
92103 }
92104
92105
92106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92107   KeyboardFocusManager arg1 ;
92108   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92109   KeyboardFocusManager *argp1 ;
92110
92111   argp1 = (KeyboardFocusManager *)jarg1;
92112   if (!argp1) {
92113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92114     return ;
92115   }
92116   arg1 = *argp1;
92117   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92118   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
92119   {
92120     try {
92121       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92122     } catch (std::out_of_range& e) {
92123       {
92124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92125       };
92126     } catch (std::exception& e) {
92127       {
92128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92129       };
92130     } catch (Dali::DaliException e) {
92131       {
92132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92133       };
92134     } catch (...) {
92135       {
92136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92137       };
92138     }
92139   }
92140
92141 }
92142
92143
92144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92145   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92146
92147   arg1 = (std::vector< unsigned int > *)jarg1;
92148   {
92149     try {
92150       (arg1)->clear();
92151     } catch (std::out_of_range& e) {
92152       {
92153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92154       };
92155     } catch (std::exception& e) {
92156       {
92157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92158       };
92159     } catch (Dali::DaliException e) {
92160       {
92161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92162       };
92163     } catch (...) {
92164       {
92165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92166       };
92167     }
92168   }
92169
92170 }
92171
92172
92173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92174   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92175   unsigned int *arg2 = 0 ;
92176   unsigned int temp2 ;
92177
92178   arg1 = (std::vector< unsigned int > *)jarg1;
92179   temp2 = (unsigned int)jarg2;
92180   arg2 = &temp2;
92181   {
92182     try {
92183       (arg1)->push_back((unsigned int const &)*arg2);
92184     } catch (std::out_of_range& e) {
92185       {
92186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92187       };
92188     } catch (std::exception& e) {
92189       {
92190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92191       };
92192     } catch (Dali::DaliException e) {
92193       {
92194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92195       };
92196     } catch (...) {
92197       {
92198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92199       };
92200     }
92201   }
92202
92203 }
92204
92205
92206 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92207   unsigned long jresult ;
92208   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92209   std::vector< unsigned int >::size_type result;
92210
92211   arg1 = (std::vector< unsigned int > *)jarg1;
92212   {
92213     try {
92214       result = ((std::vector< unsigned int > const *)arg1)->size();
92215     } catch (std::out_of_range& e) {
92216       {
92217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92218       };
92219     } catch (std::exception& e) {
92220       {
92221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92222       };
92223     } catch (Dali::DaliException e) {
92224       {
92225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92226       };
92227     } catch (...) {
92228       {
92229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92230       };
92231     }
92232   }
92233
92234   jresult = (unsigned long)result;
92235   return jresult;
92236 }
92237
92238
92239 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92240   unsigned long jresult ;
92241   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92242   std::vector< unsigned int >::size_type result;
92243
92244   arg1 = (std::vector< unsigned int > *)jarg1;
92245   {
92246     try {
92247       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92248     } catch (std::out_of_range& e) {
92249       {
92250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92251       };
92252     } catch (std::exception& e) {
92253       {
92254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92255       };
92256     } catch (Dali::DaliException e) {
92257       {
92258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92259       };
92260     } catch (...) {
92261       {
92262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92263       };
92264     }
92265   }
92266
92267   jresult = (unsigned long)result;
92268   return jresult;
92269 }
92270
92271
92272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92273   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92274   std::vector< unsigned int >::size_type arg2 ;
92275
92276   arg1 = (std::vector< unsigned int > *)jarg1;
92277   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92278   {
92279     try {
92280       (arg1)->reserve(arg2);
92281     } catch (std::out_of_range& e) {
92282       {
92283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92284       };
92285     } catch (std::exception& e) {
92286       {
92287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92288       };
92289     } catch (Dali::DaliException e) {
92290       {
92291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92292       };
92293     } catch (...) {
92294       {
92295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92296       };
92297     }
92298   }
92299
92300 }
92301
92302
92303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92304   void * jresult ;
92305   std::vector< unsigned int > *result = 0 ;
92306
92307   {
92308     try {
92309       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92310     } catch (std::out_of_range& e) {
92311       {
92312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92313       };
92314     } catch (std::exception& e) {
92315       {
92316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92317       };
92318     } catch (Dali::DaliException e) {
92319       {
92320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92321       };
92322     } catch (...) {
92323       {
92324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92325       };
92326     }
92327   }
92328
92329   jresult = (void *)result;
92330   return jresult;
92331 }
92332
92333
92334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92335   void * jresult ;
92336   std::vector< unsigned int > *arg1 = 0 ;
92337   std::vector< unsigned int > *result = 0 ;
92338
92339   arg1 = (std::vector< unsigned int > *)jarg1;
92340   if (!arg1) {
92341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92342     return 0;
92343   }
92344   {
92345     try {
92346       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92347     } catch (std::out_of_range& e) {
92348       {
92349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92350       };
92351     } catch (std::exception& e) {
92352       {
92353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92354       };
92355     } catch (Dali::DaliException e) {
92356       {
92357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92358       };
92359     } catch (...) {
92360       {
92361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92362       };
92363     }
92364   }
92365
92366   jresult = (void *)result;
92367   return jresult;
92368 }
92369
92370
92371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92372   void * jresult ;
92373   int arg1 ;
92374   std::vector< unsigned int > *result = 0 ;
92375
92376   arg1 = (int)jarg1;
92377   {
92378     try {
92379       try {
92380         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92381       }
92382       catch(std::out_of_range &_e) {
92383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92384         return 0;
92385       }
92386
92387     } catch (std::out_of_range& e) {
92388       {
92389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92390       };
92391     } catch (std::exception& e) {
92392       {
92393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92394       };
92395     } catch (Dali::DaliException e) {
92396       {
92397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92398       };
92399     } catch (...) {
92400       {
92401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92402       };
92403     }
92404   }
92405
92406   jresult = (void *)result;
92407   return jresult;
92408 }
92409
92410
92411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92412   unsigned int jresult ;
92413   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92414   int arg2 ;
92415   unsigned int result;
92416
92417   arg1 = (std::vector< unsigned int > *)jarg1;
92418   arg2 = (int)jarg2;
92419   {
92420     try {
92421       try {
92422         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92423       }
92424       catch(std::out_of_range &_e) {
92425         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92426         return 0;
92427       }
92428
92429     } catch (std::out_of_range& e) {
92430       {
92431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92432       };
92433     } catch (std::exception& e) {
92434       {
92435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92436       };
92437     } catch (Dali::DaliException e) {
92438       {
92439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92440       };
92441     } catch (...) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92444       };
92445     }
92446   }
92447
92448   jresult = result;
92449   return jresult;
92450 }
92451
92452
92453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92454   unsigned int jresult ;
92455   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92456   int arg2 ;
92457   unsigned int *result = 0 ;
92458
92459   arg1 = (std::vector< unsigned int > *)jarg1;
92460   arg2 = (int)jarg2;
92461   {
92462     try {
92463       try {
92464         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92465       }
92466       catch(std::out_of_range &_e) {
92467         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92468         return 0;
92469       }
92470
92471     } catch (std::out_of_range& e) {
92472       {
92473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92474       };
92475     } catch (std::exception& e) {
92476       {
92477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92478       };
92479     } catch (Dali::DaliException e) {
92480       {
92481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92482       };
92483     } catch (...) {
92484       {
92485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92486       };
92487     }
92488   }
92489
92490   jresult = *result;
92491   return jresult;
92492 }
92493
92494
92495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92496   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92497   int arg2 ;
92498   unsigned int *arg3 = 0 ;
92499   unsigned int temp3 ;
92500
92501   arg1 = (std::vector< unsigned int > *)jarg1;
92502   arg2 = (int)jarg2;
92503   temp3 = (unsigned int)jarg3;
92504   arg3 = &temp3;
92505   {
92506     try {
92507       try {
92508         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92509       }
92510       catch(std::out_of_range &_e) {
92511         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92512         return ;
92513       }
92514
92515     } catch (std::out_of_range& e) {
92516       {
92517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92518       };
92519     } catch (std::exception& e) {
92520       {
92521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92522       };
92523     } catch (Dali::DaliException e) {
92524       {
92525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92526       };
92527     } catch (...) {
92528       {
92529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92530       };
92531     }
92532   }
92533
92534 }
92535
92536
92537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92538   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92539   std::vector< unsigned int > *arg2 = 0 ;
92540
92541   arg1 = (std::vector< unsigned int > *)jarg1;
92542   arg2 = (std::vector< unsigned int > *)jarg2;
92543   if (!arg2) {
92544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92545     return ;
92546   }
92547   {
92548     try {
92549       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92550     } catch (std::out_of_range& e) {
92551       {
92552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92553       };
92554     } catch (std::exception& e) {
92555       {
92556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92557       };
92558     } catch (Dali::DaliException e) {
92559       {
92560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92561       };
92562     } catch (...) {
92563       {
92564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92565       };
92566     }
92567   }
92568
92569 }
92570
92571
92572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92573   void * jresult ;
92574   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92575   int arg2 ;
92576   int arg3 ;
92577   std::vector< unsigned int > *result = 0 ;
92578
92579   arg1 = (std::vector< unsigned int > *)jarg1;
92580   arg2 = (int)jarg2;
92581   arg3 = (int)jarg3;
92582   {
92583     try {
92584       try {
92585         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92586       }
92587       catch(std::out_of_range &_e) {
92588         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92589         return 0;
92590       }
92591       catch(std::invalid_argument &_e) {
92592         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92593         return 0;
92594       }
92595
92596     } catch (std::out_of_range& e) {
92597       {
92598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92599       };
92600     } catch (std::exception& e) {
92601       {
92602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92603       };
92604     } catch (Dali::DaliException e) {
92605       {
92606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92607       };
92608     } catch (...) {
92609       {
92610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92611       };
92612     }
92613   }
92614
92615   jresult = (void *)result;
92616   return jresult;
92617 }
92618
92619
92620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92621   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92622   int arg2 ;
92623   unsigned int *arg3 = 0 ;
92624   unsigned int temp3 ;
92625
92626   arg1 = (std::vector< unsigned int > *)jarg1;
92627   arg2 = (int)jarg2;
92628   temp3 = (unsigned int)jarg3;
92629   arg3 = &temp3;
92630   {
92631     try {
92632       try {
92633         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92634       }
92635       catch(std::out_of_range &_e) {
92636         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92637         return ;
92638       }
92639
92640     } catch (std::out_of_range& e) {
92641       {
92642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92643       };
92644     } catch (std::exception& e) {
92645       {
92646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92647       };
92648     } catch (Dali::DaliException e) {
92649       {
92650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92651       };
92652     } catch (...) {
92653       {
92654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92655       };
92656     }
92657   }
92658
92659 }
92660
92661
92662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92663   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92664   int arg2 ;
92665   std::vector< unsigned int > *arg3 = 0 ;
92666
92667   arg1 = (std::vector< unsigned int > *)jarg1;
92668   arg2 = (int)jarg2;
92669   arg3 = (std::vector< unsigned int > *)jarg3;
92670   if (!arg3) {
92671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92672     return ;
92673   }
92674   {
92675     try {
92676       try {
92677         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92678       }
92679       catch(std::out_of_range &_e) {
92680         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92681         return ;
92682       }
92683
92684     } catch (std::out_of_range& e) {
92685       {
92686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92687       };
92688     } catch (std::exception& e) {
92689       {
92690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92691       };
92692     } catch (Dali::DaliException e) {
92693       {
92694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92695       };
92696     } catch (...) {
92697       {
92698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92699       };
92700     }
92701   }
92702
92703 }
92704
92705
92706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92707   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92708   int arg2 ;
92709
92710   arg1 = (std::vector< unsigned int > *)jarg1;
92711   arg2 = (int)jarg2;
92712   {
92713     try {
92714       try {
92715         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92716       }
92717       catch(std::out_of_range &_e) {
92718         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92719         return ;
92720       }
92721
92722     } catch (std::out_of_range& e) {
92723       {
92724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92725       };
92726     } catch (std::exception& e) {
92727       {
92728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92729       };
92730     } catch (Dali::DaliException e) {
92731       {
92732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92733       };
92734     } catch (...) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92737       };
92738     }
92739   }
92740
92741 }
92742
92743
92744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92745   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92746   int arg2 ;
92747   int arg3 ;
92748
92749   arg1 = (std::vector< unsigned int > *)jarg1;
92750   arg2 = (int)jarg2;
92751   arg3 = (int)jarg3;
92752   {
92753     try {
92754       try {
92755         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92756       }
92757       catch(std::out_of_range &_e) {
92758         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92759         return ;
92760       }
92761       catch(std::invalid_argument &_e) {
92762         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92763         return ;
92764       }
92765
92766     } catch (std::out_of_range& e) {
92767       {
92768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92769       };
92770     } catch (std::exception& e) {
92771       {
92772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92773       };
92774     } catch (Dali::DaliException e) {
92775       {
92776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92777       };
92778     } catch (...) {
92779       {
92780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92781       };
92782     }
92783   }
92784
92785 }
92786
92787
92788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92789   void * jresult ;
92790   unsigned int *arg1 = 0 ;
92791   int arg2 ;
92792   unsigned int temp1 ;
92793   std::vector< unsigned int > *result = 0 ;
92794
92795   temp1 = (unsigned int)jarg1;
92796   arg1 = &temp1;
92797   arg2 = (int)jarg2;
92798   {
92799     try {
92800       try {
92801         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92802       }
92803       catch(std::out_of_range &_e) {
92804         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92805         return 0;
92806       }
92807
92808     } catch (std::out_of_range& e) {
92809       {
92810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92811       };
92812     } catch (std::exception& e) {
92813       {
92814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92815       };
92816     } catch (Dali::DaliException e) {
92817       {
92818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92819       };
92820     } catch (...) {
92821       {
92822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92823       };
92824     }
92825   }
92826
92827   jresult = (void *)result;
92828   return jresult;
92829 }
92830
92831
92832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92833   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92834
92835   arg1 = (std::vector< unsigned int > *)jarg1;
92836   {
92837     try {
92838       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92839     } catch (std::out_of_range& e) {
92840       {
92841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92842       };
92843     } catch (std::exception& e) {
92844       {
92845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92846       };
92847     } catch (Dali::DaliException e) {
92848       {
92849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92850       };
92851     } catch (...) {
92852       {
92853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92854       };
92855     }
92856   }
92857
92858 }
92859
92860
92861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92862   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92863   int arg2 ;
92864   int arg3 ;
92865
92866   arg1 = (std::vector< unsigned int > *)jarg1;
92867   arg2 = (int)jarg2;
92868   arg3 = (int)jarg3;
92869   {
92870     try {
92871       try {
92872         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92873       }
92874       catch(std::out_of_range &_e) {
92875         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92876         return ;
92877       }
92878       catch(std::invalid_argument &_e) {
92879         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92880         return ;
92881       }
92882
92883     } catch (std::out_of_range& e) {
92884       {
92885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92886       };
92887     } catch (std::exception& e) {
92888       {
92889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92890       };
92891     } catch (Dali::DaliException e) {
92892       {
92893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92894       };
92895     } catch (...) {
92896       {
92897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92898       };
92899     }
92900   }
92901
92902 }
92903
92904
92905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92906   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92907   int arg2 ;
92908   std::vector< unsigned int > *arg3 = 0 ;
92909
92910   arg1 = (std::vector< unsigned int > *)jarg1;
92911   arg2 = (int)jarg2;
92912   arg3 = (std::vector< unsigned int > *)jarg3;
92913   if (!arg3) {
92914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92915     return ;
92916   }
92917   {
92918     try {
92919       try {
92920         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92921       }
92922       catch(std::out_of_range &_e) {
92923         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92924         return ;
92925       }
92926
92927     } catch (std::out_of_range& e) {
92928       {
92929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92930       };
92931     } catch (std::exception& e) {
92932       {
92933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92934       };
92935     } catch (Dali::DaliException e) {
92936       {
92937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92938       };
92939     } catch (...) {
92940       {
92941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92942       };
92943     }
92944   }
92945
92946 }
92947
92948
92949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92950   unsigned int jresult ;
92951   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92952   unsigned int *arg2 = 0 ;
92953   unsigned int temp2 ;
92954   bool result;
92955
92956   arg1 = (std::vector< unsigned int > *)jarg1;
92957   temp2 = (unsigned int)jarg2;
92958   arg2 = &temp2;
92959   {
92960     try {
92961       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92962     } catch (std::out_of_range& e) {
92963       {
92964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92965       };
92966     } catch (std::exception& e) {
92967       {
92968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92969       };
92970     } catch (Dali::DaliException e) {
92971       {
92972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92973       };
92974     } catch (...) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92977       };
92978     }
92979   }
92980
92981   jresult = result;
92982   return jresult;
92983 }
92984
92985
92986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92987   int jresult ;
92988   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92989   unsigned int *arg2 = 0 ;
92990   unsigned int temp2 ;
92991   int result;
92992
92993   arg1 = (std::vector< unsigned int > *)jarg1;
92994   temp2 = (unsigned int)jarg2;
92995   arg2 = &temp2;
92996   {
92997     try {
92998       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92999     } catch (std::out_of_range& e) {
93000       {
93001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93002       };
93003     } catch (std::exception& e) {
93004       {
93005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93006       };
93007     } catch (Dali::DaliException e) {
93008       {
93009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93010       };
93011     } catch (...) {
93012       {
93013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93014       };
93015     }
93016   }
93017
93018   jresult = result;
93019   return jresult;
93020 }
93021
93022
93023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93024   int jresult ;
93025   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93026   unsigned int *arg2 = 0 ;
93027   unsigned int temp2 ;
93028   int result;
93029
93030   arg1 = (std::vector< unsigned int > *)jarg1;
93031   temp2 = (unsigned int)jarg2;
93032   arg2 = &temp2;
93033   {
93034     try {
93035       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93036     } catch (std::out_of_range& e) {
93037       {
93038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93039       };
93040     } catch (std::exception& e) {
93041       {
93042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93043       };
93044     } catch (Dali::DaliException e) {
93045       {
93046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93047       };
93048     } catch (...) {
93049       {
93050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93051       };
93052     }
93053   }
93054
93055   jresult = result;
93056   return jresult;
93057 }
93058
93059
93060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93061   unsigned int jresult ;
93062   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93063   unsigned int *arg2 = 0 ;
93064   unsigned int temp2 ;
93065   bool result;
93066
93067   arg1 = (std::vector< unsigned int > *)jarg1;
93068   temp2 = (unsigned int)jarg2;
93069   arg2 = &temp2;
93070   {
93071     try {
93072       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93073     } catch (std::out_of_range& e) {
93074       {
93075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93076       };
93077     } catch (std::exception& e) {
93078       {
93079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93080       };
93081     } catch (Dali::DaliException e) {
93082       {
93083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93084       };
93085     } catch (...) {
93086       {
93087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93088       };
93089     }
93090   }
93091
93092   jresult = result;
93093   return jresult;
93094 }
93095
93096
93097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93098   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93099
93100   arg1 = (std::vector< unsigned int > *)jarg1;
93101   {
93102     try {
93103       delete arg1;
93104     } catch (std::out_of_range& e) {
93105       {
93106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93107       };
93108     } catch (std::exception& e) {
93109       {
93110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93111       };
93112     } catch (Dali::DaliException e) {
93113       {
93114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93115       };
93116     } catch (...) {
93117       {
93118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93119       };
93120     }
93121   }
93122
93123 }
93124
93125
93126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93127   void * jresult ;
93128   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93129
93130   {
93131     try {
93132       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93133     } catch (std::out_of_range& e) {
93134       {
93135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93136       };
93137     } catch (std::exception& e) {
93138       {
93139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93140       };
93141     } catch (Dali::DaliException e) {
93142       {
93143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93144       };
93145     } catch (...) {
93146       {
93147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93148       };
93149     }
93150   }
93151
93152   jresult = (void *)result;
93153   return jresult;
93154 }
93155
93156
93157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93158   void * jresult ;
93159   unsigned int arg1 ;
93160   Dali::Actor arg2 ;
93161   Dali::Actor *argp2 ;
93162   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93163
93164   arg1 = (unsigned int)jarg1;
93165   argp2 = (Dali::Actor *)jarg2;
93166   if (!argp2) {
93167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93168     return 0;
93169   }
93170   arg2 = *argp2;
93171   {
93172     try {
93173       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93174     } catch (std::out_of_range& e) {
93175       {
93176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93177       };
93178     } catch (std::exception& e) {
93179       {
93180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93181       };
93182     } catch (Dali::DaliException e) {
93183       {
93184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93185       };
93186     } catch (...) {
93187       {
93188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93189       };
93190     }
93191   }
93192
93193   jresult = (void *)result;
93194   return jresult;
93195 }
93196
93197
93198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93199   void * jresult ;
93200   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93201   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93202
93203   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93204   if (!arg1) {
93205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93206     return 0;
93207   }
93208   {
93209     try {
93210       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93211     } catch (std::out_of_range& e) {
93212       {
93213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93214       };
93215     } catch (std::exception& e) {
93216       {
93217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93218       };
93219     } catch (Dali::DaliException e) {
93220       {
93221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93222       };
93223     } catch (...) {
93224       {
93225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93226       };
93227     }
93228   }
93229
93230   jresult = (void *)result;
93231   return jresult;
93232 }
93233
93234
93235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93236   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93237   unsigned int arg2 ;
93238
93239   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93240   arg2 = (unsigned int)jarg2;
93241   if (arg1) (arg1)->first = arg2;
93242 }
93243
93244
93245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93246   unsigned int jresult ;
93247   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93248   unsigned int result;
93249
93250   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93251   result = (unsigned int) ((arg1)->first);
93252   jresult = result;
93253   return jresult;
93254 }
93255
93256
93257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93258   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93259   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93260
93261   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93262   arg2 = (Dali::Actor *)jarg2;
93263   if (arg1) (arg1)->second = *arg2;
93264 }
93265
93266
93267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93268   void * jresult ;
93269   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93270   Dali::Actor *result = 0 ;
93271
93272   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93273   result = (Dali::Actor *)& ((arg1)->second);
93274   jresult = (void *)result;
93275   return jresult;
93276 }
93277
93278
93279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93280   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93281
93282   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93283   {
93284     try {
93285       delete arg1;
93286     } catch (std::out_of_range& e) {
93287       {
93288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93289       };
93290     } catch (std::exception& e) {
93291       {
93292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93293       };
93294     } catch (Dali::DaliException e) {
93295       {
93296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93297       };
93298     } catch (...) {
93299       {
93300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93301       };
93302     }
93303   }
93304
93305 }
93306
93307
93308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93309   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93310
93311   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93312   {
93313     try {
93314       (arg1)->clear();
93315     } catch (std::out_of_range& e) {
93316       {
93317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93318       };
93319     } catch (std::exception& e) {
93320       {
93321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93322       };
93323     } catch (Dali::DaliException e) {
93324       {
93325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93326       };
93327     } catch (...) {
93328       {
93329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93330       };
93331     }
93332   }
93333
93334 }
93335
93336
93337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93338   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93339   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93340
93341   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93342   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93343   if (!arg2) {
93344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93345     return ;
93346   }
93347   {
93348     try {
93349       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93350     } catch (std::out_of_range& e) {
93351       {
93352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93353       };
93354     } catch (std::exception& e) {
93355       {
93356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93357       };
93358     } catch (Dali::DaliException e) {
93359       {
93360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93361       };
93362     } catch (...) {
93363       {
93364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93365       };
93366     }
93367   }
93368
93369 }
93370
93371
93372 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93373   unsigned long jresult ;
93374   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93375   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93376
93377   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93378   {
93379     try {
93380       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93381     } catch (std::out_of_range& e) {
93382       {
93383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93384       };
93385     } catch (std::exception& e) {
93386       {
93387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93388       };
93389     } catch (Dali::DaliException e) {
93390       {
93391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93392       };
93393     } catch (...) {
93394       {
93395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93396       };
93397     }
93398   }
93399
93400   jresult = (unsigned long)result;
93401   return jresult;
93402 }
93403
93404
93405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93406   unsigned long jresult ;
93407   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93408   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93409
93410   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93411   {
93412     try {
93413       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93414     } catch (std::out_of_range& e) {
93415       {
93416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93417       };
93418     } catch (std::exception& e) {
93419       {
93420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93421       };
93422     } catch (Dali::DaliException e) {
93423       {
93424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93425       };
93426     } catch (...) {
93427       {
93428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93429       };
93430     }
93431   }
93432
93433   jresult = (unsigned long)result;
93434   return jresult;
93435 }
93436
93437
93438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93439   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93440   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93441
93442   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93443   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93444   {
93445     try {
93446       (arg1)->reserve(arg2);
93447     } catch (std::out_of_range& e) {
93448       {
93449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93450       };
93451     } catch (std::exception& e) {
93452       {
93453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93454       };
93455     } catch (Dali::DaliException e) {
93456       {
93457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93458       };
93459     } catch (...) {
93460       {
93461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93462       };
93463     }
93464   }
93465
93466 }
93467
93468
93469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93470   void * jresult ;
93471   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93472
93473   {
93474     try {
93475       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93476     } catch (std::out_of_range& e) {
93477       {
93478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93479       };
93480     } catch (std::exception& e) {
93481       {
93482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93483       };
93484     } catch (Dali::DaliException e) {
93485       {
93486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93487       };
93488     } catch (...) {
93489       {
93490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93491       };
93492     }
93493   }
93494
93495   jresult = (void *)result;
93496   return jresult;
93497 }
93498
93499
93500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93501   void * jresult ;
93502   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93503   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93504
93505   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93506   if (!arg1) {
93507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93508     return 0;
93509   }
93510   {
93511     try {
93512       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);
93513     } catch (std::out_of_range& e) {
93514       {
93515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93516       };
93517     } catch (std::exception& e) {
93518       {
93519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93520       };
93521     } catch (Dali::DaliException e) {
93522       {
93523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93524       };
93525     } catch (...) {
93526       {
93527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93528       };
93529     }
93530   }
93531
93532   jresult = (void *)result;
93533   return jresult;
93534 }
93535
93536
93537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93538   void * jresult ;
93539   int arg1 ;
93540   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93541
93542   arg1 = (int)jarg1;
93543   {
93544     try {
93545       try {
93546         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);
93547       }
93548       catch(std::out_of_range &_e) {
93549         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93550         return 0;
93551       }
93552
93553     } catch (std::out_of_range& e) {
93554       {
93555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93556       };
93557     } catch (std::exception& e) {
93558       {
93559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93560       };
93561     } catch (Dali::DaliException e) {
93562       {
93563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93564       };
93565     } catch (...) {
93566       {
93567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93568       };
93569     }
93570   }
93571
93572   jresult = (void *)result;
93573   return jresult;
93574 }
93575
93576
93577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93578   void * jresult ;
93579   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93580   int arg2 ;
93581   std::pair< unsigned int,Dali::Actor > result;
93582
93583   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93584   arg2 = (int)jarg2;
93585   {
93586     try {
93587       try {
93588         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93589       }
93590       catch(std::out_of_range &_e) {
93591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93592         return 0;
93593       }
93594
93595     } catch (std::out_of_range& e) {
93596       {
93597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93598       };
93599     } catch (std::exception& e) {
93600       {
93601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93602       };
93603     } catch (Dali::DaliException e) {
93604       {
93605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93606       };
93607     } catch (...) {
93608       {
93609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93610       };
93611     }
93612   }
93613
93614   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93615   return jresult;
93616 }
93617
93618
93619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93620   void * jresult ;
93621   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93622   int arg2 ;
93623   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93624
93625   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93626   arg2 = (int)jarg2;
93627   {
93628     try {
93629       try {
93630         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93631       }
93632       catch(std::out_of_range &_e) {
93633         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93634         return 0;
93635       }
93636
93637     } catch (std::out_of_range& e) {
93638       {
93639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93640       };
93641     } catch (std::exception& e) {
93642       {
93643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93644       };
93645     } catch (Dali::DaliException e) {
93646       {
93647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93648       };
93649     } catch (...) {
93650       {
93651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93652       };
93653     }
93654   }
93655
93656   jresult = (void *)result;
93657   return jresult;
93658 }
93659
93660
93661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93662   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93663   int arg2 ;
93664   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93665
93666   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93667   arg2 = (int)jarg2;
93668   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93669   if (!arg3) {
93670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93671     return ;
93672   }
93673   {
93674     try {
93675       try {
93676         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);
93677       }
93678       catch(std::out_of_range &_e) {
93679         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93680         return ;
93681       }
93682
93683     } catch (std::out_of_range& e) {
93684       {
93685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93686       };
93687     } catch (std::exception& e) {
93688       {
93689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93690       };
93691     } catch (Dali::DaliException e) {
93692       {
93693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93694       };
93695     } catch (...) {
93696       {
93697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93698       };
93699     }
93700   }
93701
93702 }
93703
93704
93705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93706   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93707   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93708
93709   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93710   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93711   if (!arg2) {
93712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93713     return ;
93714   }
93715   {
93716     try {
93717       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);
93718     } catch (std::out_of_range& e) {
93719       {
93720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93721       };
93722     } catch (std::exception& e) {
93723       {
93724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93725       };
93726     } catch (Dali::DaliException e) {
93727       {
93728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93729       };
93730     } catch (...) {
93731       {
93732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93733       };
93734     }
93735   }
93736
93737 }
93738
93739
93740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93741   void * jresult ;
93742   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93743   int arg2 ;
93744   int arg3 ;
93745   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93746
93747   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93748   arg2 = (int)jarg2;
93749   arg3 = (int)jarg3;
93750   {
93751     try {
93752       try {
93753         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);
93754       }
93755       catch(std::out_of_range &_e) {
93756         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93757         return 0;
93758       }
93759       catch(std::invalid_argument &_e) {
93760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93761         return 0;
93762       }
93763
93764     } catch (std::out_of_range& e) {
93765       {
93766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93767       };
93768     } catch (std::exception& e) {
93769       {
93770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93771       };
93772     } catch (Dali::DaliException e) {
93773       {
93774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93775       };
93776     } catch (...) {
93777       {
93778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93779       };
93780     }
93781   }
93782
93783   jresult = (void *)result;
93784   return jresult;
93785 }
93786
93787
93788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93789   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93790   int arg2 ;
93791   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93792
93793   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93794   arg2 = (int)jarg2;
93795   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93796   if (!arg3) {
93797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93798     return ;
93799   }
93800   {
93801     try {
93802       try {
93803         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);
93804       }
93805       catch(std::out_of_range &_e) {
93806         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93807         return ;
93808       }
93809
93810     } catch (std::out_of_range& e) {
93811       {
93812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93813       };
93814     } catch (std::exception& e) {
93815       {
93816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93817       };
93818     } catch (Dali::DaliException e) {
93819       {
93820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93821       };
93822     } catch (...) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93825       };
93826     }
93827   }
93828
93829 }
93830
93831
93832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93833   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93834   int arg2 ;
93835   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93836
93837   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93838   arg2 = (int)jarg2;
93839   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93840   if (!arg3) {
93841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93842     return ;
93843   }
93844   {
93845     try {
93846       try {
93847         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);
93848       }
93849       catch(std::out_of_range &_e) {
93850         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93851         return ;
93852       }
93853
93854     } catch (std::out_of_range& e) {
93855       {
93856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93857       };
93858     } catch (std::exception& e) {
93859       {
93860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93861       };
93862     } catch (Dali::DaliException e) {
93863       {
93864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93865       };
93866     } catch (...) {
93867       {
93868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93869       };
93870     }
93871   }
93872
93873 }
93874
93875
93876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93877   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93878   int arg2 ;
93879
93880   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93881   arg2 = (int)jarg2;
93882   {
93883     try {
93884       try {
93885         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93886       }
93887       catch(std::out_of_range &_e) {
93888         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93889         return ;
93890       }
93891
93892     } catch (std::out_of_range& e) {
93893       {
93894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93895       };
93896     } catch (std::exception& e) {
93897       {
93898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93899       };
93900     } catch (Dali::DaliException e) {
93901       {
93902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93903       };
93904     } catch (...) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93907       };
93908     }
93909   }
93910
93911 }
93912
93913
93914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93915   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93916   int arg2 ;
93917   int arg3 ;
93918
93919   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93920   arg2 = (int)jarg2;
93921   arg3 = (int)jarg3;
93922   {
93923     try {
93924       try {
93925         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93926       }
93927       catch(std::out_of_range &_e) {
93928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93929         return ;
93930       }
93931       catch(std::invalid_argument &_e) {
93932         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93933         return ;
93934       }
93935
93936     } catch (std::out_of_range& e) {
93937       {
93938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93939       };
93940     } catch (std::exception& e) {
93941       {
93942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93943       };
93944     } catch (Dali::DaliException e) {
93945       {
93946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93947       };
93948     } catch (...) {
93949       {
93950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93951       };
93952     }
93953   }
93954
93955 }
93956
93957
93958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93959   void * jresult ;
93960   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93961   int arg2 ;
93962   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93963
93964   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93965   if (!arg1) {
93966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93967     return 0;
93968   }
93969   arg2 = (int)jarg2;
93970   {
93971     try {
93972       try {
93973         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);
93974       }
93975       catch(std::out_of_range &_e) {
93976         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93977         return 0;
93978       }
93979
93980     } catch (std::out_of_range& e) {
93981       {
93982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93983       };
93984     } catch (std::exception& e) {
93985       {
93986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93987       };
93988     } catch (Dali::DaliException e) {
93989       {
93990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93991       };
93992     } catch (...) {
93993       {
93994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93995       };
93996     }
93997   }
93998
93999   jresult = (void *)result;
94000   return jresult;
94001 }
94002
94003
94004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94005   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94006
94007   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94008   {
94009     try {
94010       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94011     } catch (std::out_of_range& e) {
94012       {
94013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94014       };
94015     } catch (std::exception& e) {
94016       {
94017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94018       };
94019     } catch (Dali::DaliException e) {
94020       {
94021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94022       };
94023     } catch (...) {
94024       {
94025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94026       };
94027     }
94028   }
94029
94030 }
94031
94032
94033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94034   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94035   int arg2 ;
94036   int arg3 ;
94037
94038   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94039   arg2 = (int)jarg2;
94040   arg3 = (int)jarg3;
94041   {
94042     try {
94043       try {
94044         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94045       }
94046       catch(std::out_of_range &_e) {
94047         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94048         return ;
94049       }
94050       catch(std::invalid_argument &_e) {
94051         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94052         return ;
94053       }
94054
94055     } catch (std::out_of_range& e) {
94056       {
94057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94058       };
94059     } catch (std::exception& e) {
94060       {
94061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94062       };
94063     } catch (Dali::DaliException e) {
94064       {
94065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94066       };
94067     } catch (...) {
94068       {
94069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94070       };
94071     }
94072   }
94073
94074 }
94075
94076
94077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94078   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94079   int arg2 ;
94080   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94081
94082   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94083   arg2 = (int)jarg2;
94084   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94085   if (!arg3) {
94086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94087     return ;
94088   }
94089   {
94090     try {
94091       try {
94092         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);
94093       }
94094       catch(std::out_of_range &_e) {
94095         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94096         return ;
94097       }
94098
94099     } catch (std::out_of_range& e) {
94100       {
94101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94102       };
94103     } catch (std::exception& e) {
94104       {
94105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94106       };
94107     } catch (Dali::DaliException e) {
94108       {
94109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94110       };
94111     } catch (...) {
94112       {
94113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94114       };
94115     }
94116   }
94117
94118 }
94119
94120
94121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94122   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94123
94124   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94125   {
94126     try {
94127       delete arg1;
94128     } catch (std::out_of_range& e) {
94129       {
94130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94131       };
94132     } catch (std::exception& e) {
94133       {
94134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94135       };
94136     } catch (Dali::DaliException e) {
94137       {
94138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94139       };
94140     } catch (...) {
94141       {
94142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94143       };
94144     }
94145   }
94146
94147 }
94148
94149
94150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94151   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94152
94153   arg1 = (std::vector< Dali::Actor > *)jarg1;
94154   {
94155     try {
94156       (arg1)->clear();
94157     } catch (std::out_of_range& e) {
94158       {
94159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94160       };
94161     } catch (std::exception& e) {
94162       {
94163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94164       };
94165     } catch (Dali::DaliException e) {
94166       {
94167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94168       };
94169     } catch (...) {
94170       {
94171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94172       };
94173     }
94174   }
94175
94176 }
94177
94178
94179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94180   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94181   Dali::Actor *arg2 = 0 ;
94182
94183   arg1 = (std::vector< Dali::Actor > *)jarg1;
94184   arg2 = (Dali::Actor *)jarg2;
94185   if (!arg2) {
94186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94187     return ;
94188   }
94189   {
94190     try {
94191       (arg1)->push_back((Dali::Actor const &)*arg2);
94192     } catch (std::out_of_range& e) {
94193       {
94194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94195       };
94196     } catch (std::exception& e) {
94197       {
94198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94199       };
94200     } catch (Dali::DaliException e) {
94201       {
94202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94203       };
94204     } catch (...) {
94205       {
94206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94207       };
94208     }
94209   }
94210
94211 }
94212
94213
94214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94215   unsigned long jresult ;
94216   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94217   std::vector< Dali::Actor >::size_type result;
94218
94219   arg1 = (std::vector< Dali::Actor > *)jarg1;
94220   {
94221     try {
94222       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94223     } catch (std::out_of_range& e) {
94224       {
94225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94226       };
94227     } catch (std::exception& e) {
94228       {
94229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94230       };
94231     } catch (Dali::DaliException e) {
94232       {
94233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94234       };
94235     } catch (...) {
94236       {
94237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94238       };
94239     }
94240   }
94241
94242   jresult = (unsigned long)result;
94243   return jresult;
94244 }
94245
94246
94247 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94248   unsigned long jresult ;
94249   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94250   std::vector< Dali::Actor >::size_type result;
94251
94252   arg1 = (std::vector< Dali::Actor > *)jarg1;
94253   {
94254     try {
94255       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94256     } catch (std::out_of_range& e) {
94257       {
94258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94259       };
94260     } catch (std::exception& e) {
94261       {
94262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94263       };
94264     } catch (Dali::DaliException e) {
94265       {
94266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94267       };
94268     } catch (...) {
94269       {
94270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94271       };
94272     }
94273   }
94274
94275   jresult = (unsigned long)result;
94276   return jresult;
94277 }
94278
94279
94280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94281   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94282   std::vector< Dali::Actor >::size_type arg2 ;
94283
94284   arg1 = (std::vector< Dali::Actor > *)jarg1;
94285   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94286   {
94287     try {
94288       (arg1)->reserve(arg2);
94289     } catch (std::out_of_range& e) {
94290       {
94291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94292       };
94293     } catch (std::exception& e) {
94294       {
94295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94296       };
94297     } catch (Dali::DaliException e) {
94298       {
94299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94300       };
94301     } catch (...) {
94302       {
94303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94304       };
94305     }
94306   }
94307
94308 }
94309
94310
94311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94312   void * jresult ;
94313   std::vector< Dali::Actor > *result = 0 ;
94314
94315   {
94316     try {
94317       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94318     } catch (std::out_of_range& e) {
94319       {
94320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94321       };
94322     } catch (std::exception& e) {
94323       {
94324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94325       };
94326     } catch (Dali::DaliException e) {
94327       {
94328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94329       };
94330     } catch (...) {
94331       {
94332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94333       };
94334     }
94335   }
94336
94337   jresult = (void *)result;
94338   return jresult;
94339 }
94340
94341
94342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94343   void * jresult ;
94344   std::vector< Dali::Actor > *arg1 = 0 ;
94345   std::vector< Dali::Actor > *result = 0 ;
94346
94347   arg1 = (std::vector< Dali::Actor > *)jarg1;
94348   if (!arg1) {
94349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94350     return 0;
94351   }
94352   {
94353     try {
94354       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94355     } catch (std::out_of_range& e) {
94356       {
94357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94358       };
94359     } catch (std::exception& e) {
94360       {
94361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94362       };
94363     } catch (Dali::DaliException e) {
94364       {
94365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94366       };
94367     } catch (...) {
94368       {
94369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94370       };
94371     }
94372   }
94373
94374   jresult = (void *)result;
94375   return jresult;
94376 }
94377
94378
94379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94380   void * jresult ;
94381   int arg1 ;
94382   std::vector< Dali::Actor > *result = 0 ;
94383
94384   arg1 = (int)jarg1;
94385   {
94386     try {
94387       try {
94388         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94389       }
94390       catch(std::out_of_range &_e) {
94391         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94392         return 0;
94393       }
94394
94395     } catch (std::out_of_range& e) {
94396       {
94397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94398       };
94399     } catch (std::exception& e) {
94400       {
94401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94402       };
94403     } catch (Dali::DaliException e) {
94404       {
94405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94406       };
94407     } catch (...) {
94408       {
94409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94410       };
94411     }
94412   }
94413
94414   jresult = (void *)result;
94415   return jresult;
94416 }
94417
94418
94419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94420   void * jresult ;
94421   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94422   int arg2 ;
94423   Dali::Actor result;
94424
94425   arg1 = (std::vector< Dali::Actor > *)jarg1;
94426   arg2 = (int)jarg2;
94427   {
94428     try {
94429       try {
94430         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94431       }
94432       catch(std::out_of_range &_e) {
94433         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94434         return 0;
94435       }
94436
94437     } catch (std::out_of_range& e) {
94438       {
94439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94440       };
94441     } catch (std::exception& e) {
94442       {
94443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94444       };
94445     } catch (Dali::DaliException e) {
94446       {
94447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94448       };
94449     } catch (...) {
94450       {
94451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94452       };
94453     }
94454   }
94455
94456   jresult = new Dali::Actor((const Dali::Actor &)result);
94457   return jresult;
94458 }
94459
94460
94461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94462   void * jresult ;
94463   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94464   int arg2 ;
94465   Dali::Actor *result = 0 ;
94466
94467   arg1 = (std::vector< Dali::Actor > *)jarg1;
94468   arg2 = (int)jarg2;
94469   {
94470     try {
94471       try {
94472         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94473       }
94474       catch(std::out_of_range &_e) {
94475         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94476         return 0;
94477       }
94478
94479     } catch (std::out_of_range& e) {
94480       {
94481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94482       };
94483     } catch (std::exception& e) {
94484       {
94485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94486       };
94487     } catch (Dali::DaliException e) {
94488       {
94489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94490       };
94491     } catch (...) {
94492       {
94493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94494       };
94495     }
94496   }
94497
94498   jresult = (void *)result;
94499   return jresult;
94500 }
94501
94502
94503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94504   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94505   int arg2 ;
94506   Dali::Actor *arg3 = 0 ;
94507
94508   arg1 = (std::vector< Dali::Actor > *)jarg1;
94509   arg2 = (int)jarg2;
94510   arg3 = (Dali::Actor *)jarg3;
94511   if (!arg3) {
94512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94513     return ;
94514   }
94515   {
94516     try {
94517       try {
94518         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94519       }
94520       catch(std::out_of_range &_e) {
94521         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94522         return ;
94523       }
94524
94525     } catch (std::out_of_range& e) {
94526       {
94527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94528       };
94529     } catch (std::exception& e) {
94530       {
94531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94532       };
94533     } catch (Dali::DaliException e) {
94534       {
94535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94536       };
94537     } catch (...) {
94538       {
94539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94540       };
94541     }
94542   }
94543
94544 }
94545
94546
94547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94548   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94549   std::vector< Dali::Actor > *arg2 = 0 ;
94550
94551   arg1 = (std::vector< Dali::Actor > *)jarg1;
94552   arg2 = (std::vector< Dali::Actor > *)jarg2;
94553   if (!arg2) {
94554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94555     return ;
94556   }
94557   {
94558     try {
94559       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94560     } catch (std::out_of_range& e) {
94561       {
94562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94563       };
94564     } catch (std::exception& e) {
94565       {
94566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94567       };
94568     } catch (Dali::DaliException e) {
94569       {
94570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94571       };
94572     } catch (...) {
94573       {
94574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94575       };
94576     }
94577   }
94578
94579 }
94580
94581
94582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94583   void * jresult ;
94584   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94585   int arg2 ;
94586   int arg3 ;
94587   std::vector< Dali::Actor > *result = 0 ;
94588
94589   arg1 = (std::vector< Dali::Actor > *)jarg1;
94590   arg2 = (int)jarg2;
94591   arg3 = (int)jarg3;
94592   {
94593     try {
94594       try {
94595         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94596       }
94597       catch(std::out_of_range &_e) {
94598         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94599         return 0;
94600       }
94601       catch(std::invalid_argument &_e) {
94602         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94603         return 0;
94604       }
94605
94606     } catch (std::out_of_range& e) {
94607       {
94608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94609       };
94610     } catch (std::exception& e) {
94611       {
94612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94613       };
94614     } catch (Dali::DaliException e) {
94615       {
94616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94617       };
94618     } catch (...) {
94619       {
94620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94621       };
94622     }
94623   }
94624
94625   jresult = (void *)result;
94626   return jresult;
94627 }
94628
94629
94630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94631   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94632   int arg2 ;
94633   Dali::Actor *arg3 = 0 ;
94634
94635   arg1 = (std::vector< Dali::Actor > *)jarg1;
94636   arg2 = (int)jarg2;
94637   arg3 = (Dali::Actor *)jarg3;
94638   if (!arg3) {
94639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94640     return ;
94641   }
94642   {
94643     try {
94644       try {
94645         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94646       }
94647       catch(std::out_of_range &_e) {
94648         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94649         return ;
94650       }
94651
94652     } catch (std::out_of_range& e) {
94653       {
94654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94655       };
94656     } catch (std::exception& e) {
94657       {
94658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94659       };
94660     } catch (Dali::DaliException e) {
94661       {
94662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94663       };
94664     } catch (...) {
94665       {
94666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94667       };
94668     }
94669   }
94670
94671 }
94672
94673
94674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94675   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94676   int arg2 ;
94677   std::vector< Dali::Actor > *arg3 = 0 ;
94678
94679   arg1 = (std::vector< Dali::Actor > *)jarg1;
94680   arg2 = (int)jarg2;
94681   arg3 = (std::vector< Dali::Actor > *)jarg3;
94682   if (!arg3) {
94683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94684     return ;
94685   }
94686   {
94687     try {
94688       try {
94689         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94690       }
94691       catch(std::out_of_range &_e) {
94692         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94693         return ;
94694       }
94695
94696     } catch (std::out_of_range& e) {
94697       {
94698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94699       };
94700     } catch (std::exception& e) {
94701       {
94702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94703       };
94704     } catch (Dali::DaliException e) {
94705       {
94706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94707       };
94708     } catch (...) {
94709       {
94710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94711       };
94712     }
94713   }
94714
94715 }
94716
94717
94718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94719   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94720   int arg2 ;
94721
94722   arg1 = (std::vector< Dali::Actor > *)jarg1;
94723   arg2 = (int)jarg2;
94724   {
94725     try {
94726       try {
94727         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94728       }
94729       catch(std::out_of_range &_e) {
94730         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94731         return ;
94732       }
94733
94734     } catch (std::out_of_range& e) {
94735       {
94736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94737       };
94738     } catch (std::exception& e) {
94739       {
94740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94741       };
94742     } catch (Dali::DaliException e) {
94743       {
94744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94745       };
94746     } catch (...) {
94747       {
94748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94749       };
94750     }
94751   }
94752
94753 }
94754
94755
94756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94757   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94758   int arg2 ;
94759   int arg3 ;
94760
94761   arg1 = (std::vector< Dali::Actor > *)jarg1;
94762   arg2 = (int)jarg2;
94763   arg3 = (int)jarg3;
94764   {
94765     try {
94766       try {
94767         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94768       }
94769       catch(std::out_of_range &_e) {
94770         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94771         return ;
94772       }
94773       catch(std::invalid_argument &_e) {
94774         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94775         return ;
94776       }
94777
94778     } catch (std::out_of_range& e) {
94779       {
94780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94781       };
94782     } catch (std::exception& e) {
94783       {
94784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94785       };
94786     } catch (Dali::DaliException e) {
94787       {
94788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94789       };
94790     } catch (...) {
94791       {
94792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94793       };
94794     }
94795   }
94796
94797 }
94798
94799
94800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94801   void * jresult ;
94802   Dali::Actor *arg1 = 0 ;
94803   int arg2 ;
94804   std::vector< Dali::Actor > *result = 0 ;
94805
94806   arg1 = (Dali::Actor *)jarg1;
94807   if (!arg1) {
94808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94809     return 0;
94810   }
94811   arg2 = (int)jarg2;
94812   {
94813     try {
94814       try {
94815         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94816       }
94817       catch(std::out_of_range &_e) {
94818         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94819         return 0;
94820       }
94821
94822     } catch (std::out_of_range& e) {
94823       {
94824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94825       };
94826     } catch (std::exception& e) {
94827       {
94828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94829       };
94830     } catch (Dali::DaliException e) {
94831       {
94832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94833       };
94834     } catch (...) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94837       };
94838     }
94839   }
94840
94841   jresult = (void *)result;
94842   return jresult;
94843 }
94844
94845
94846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94847   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94848
94849   arg1 = (std::vector< Dali::Actor > *)jarg1;
94850   {
94851     try {
94852       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94853     } catch (std::out_of_range& e) {
94854       {
94855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94856       };
94857     } catch (std::exception& e) {
94858       {
94859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94860       };
94861     } catch (Dali::DaliException e) {
94862       {
94863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94864       };
94865     } catch (...) {
94866       {
94867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94868       };
94869     }
94870   }
94871
94872 }
94873
94874
94875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94876   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94877   int arg2 ;
94878   int arg3 ;
94879
94880   arg1 = (std::vector< Dali::Actor > *)jarg1;
94881   arg2 = (int)jarg2;
94882   arg3 = (int)jarg3;
94883   {
94884     try {
94885       try {
94886         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94887       }
94888       catch(std::out_of_range &_e) {
94889         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94890         return ;
94891       }
94892       catch(std::invalid_argument &_e) {
94893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94894         return ;
94895       }
94896
94897     } catch (std::out_of_range& e) {
94898       {
94899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94900       };
94901     } catch (std::exception& e) {
94902       {
94903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94904       };
94905     } catch (Dali::DaliException e) {
94906       {
94907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94908       };
94909     } catch (...) {
94910       {
94911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94912       };
94913     }
94914   }
94915
94916 }
94917
94918
94919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94920   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94921   int arg2 ;
94922   std::vector< Dali::Actor > *arg3 = 0 ;
94923
94924   arg1 = (std::vector< Dali::Actor > *)jarg1;
94925   arg2 = (int)jarg2;
94926   arg3 = (std::vector< Dali::Actor > *)jarg3;
94927   if (!arg3) {
94928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94929     return ;
94930   }
94931   {
94932     try {
94933       try {
94934         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94935       }
94936       catch(std::out_of_range &_e) {
94937         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94938         return ;
94939       }
94940
94941     } catch (std::out_of_range& e) {
94942       {
94943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94944       };
94945     } catch (std::exception& e) {
94946       {
94947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94948       };
94949     } catch (Dali::DaliException e) {
94950       {
94951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94952       };
94953     } catch (...) {
94954       {
94955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94956       };
94957     }
94958   }
94959
94960 }
94961
94962
94963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94964   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94965
94966   arg1 = (std::vector< Dali::Actor > *)jarg1;
94967   {
94968     try {
94969       delete arg1;
94970     } catch (std::out_of_range& e) {
94971       {
94972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94973       };
94974     } catch (std::exception& e) {
94975       {
94976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94977       };
94978     } catch (Dali::DaliException e) {
94979       {
94980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94981       };
94982     } catch (...) {
94983       {
94984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94985       };
94986     }
94987   }
94988
94989 }
94990
94991
94992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94993   unsigned int jresult ;
94994   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94995   bool result;
94996
94997   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94998   {
94999     try {
95000       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95001     } catch (std::out_of_range& e) {
95002       {
95003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95004       };
95005     } catch (std::exception& e) {
95006       {
95007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95008       };
95009     } catch (Dali::DaliException e) {
95010       {
95011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95012       };
95013     } catch (...) {
95014       {
95015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95016       };
95017     }
95018   }
95019
95020   jresult = result;
95021   return jresult;
95022 }
95023
95024
95025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95026   unsigned long jresult ;
95027   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95028   std::size_t result;
95029
95030   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95031   {
95032     try {
95033       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95034     } catch (std::out_of_range& e) {
95035       {
95036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95037       };
95038     } catch (std::exception& e) {
95039       {
95040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95041       };
95042     } catch (Dali::DaliException e) {
95043       {
95044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95045       };
95046     } catch (...) {
95047       {
95048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95049       };
95050     }
95051   }
95052
95053   jresult = (unsigned long)result;
95054   return jresult;
95055 }
95056
95057
95058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95059   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95060   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95061
95062   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95063   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95064   {
95065     try {
95066       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95067     } catch (std::out_of_range& e) {
95068       {
95069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95070       };
95071     } catch (std::exception& e) {
95072       {
95073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95074       };
95075     } catch (Dali::DaliException e) {
95076       {
95077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95078       };
95079     } catch (...) {
95080       {
95081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95082       };
95083     }
95084   }
95085
95086 }
95087
95088
95089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95090   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95091   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95092
95093   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95094   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95095   {
95096     try {
95097       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95098     } catch (std::out_of_range& e) {
95099       {
95100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95101       };
95102     } catch (std::exception& e) {
95103       {
95104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95105       };
95106     } catch (Dali::DaliException e) {
95107       {
95108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95109       };
95110     } catch (...) {
95111       {
95112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95113       };
95114     }
95115   }
95116
95117 }
95118
95119
95120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95121   unsigned int jresult ;
95122   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95123   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95124   bool result;
95125
95126   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95127   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95128   if (!arg2) {
95129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95130     return 0;
95131   }
95132   {
95133     try {
95134       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95135     } catch (std::out_of_range& e) {
95136       {
95137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95138       };
95139     } catch (std::exception& e) {
95140       {
95141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95142       };
95143     } catch (Dali::DaliException e) {
95144       {
95145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95146       };
95147     } catch (...) {
95148       {
95149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95150       };
95151     }
95152   }
95153
95154   jresult = result;
95155   return jresult;
95156 }
95157
95158
95159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95160   void * jresult ;
95161   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95162
95163   {
95164     try {
95165       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95166     } catch (std::out_of_range& e) {
95167       {
95168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95169       };
95170     } catch (std::exception& e) {
95171       {
95172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95173       };
95174     } catch (Dali::DaliException e) {
95175       {
95176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95177       };
95178     } catch (...) {
95179       {
95180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95181       };
95182     }
95183   }
95184
95185   jresult = (void *)result;
95186   return jresult;
95187 }
95188
95189
95190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95191   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95192
95193   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95194   {
95195     try {
95196       delete arg1;
95197     } catch (std::out_of_range& e) {
95198       {
95199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95200       };
95201     } catch (std::exception& e) {
95202       {
95203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95204       };
95205     } catch (Dali::DaliException e) {
95206       {
95207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95208       };
95209     } catch (...) {
95210       {
95211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95212       };
95213     }
95214   }
95215
95216 }
95217
95218
95219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95220   unsigned int jresult ;
95221   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95222   bool result;
95223
95224   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95225   {
95226     try {
95227       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);
95228     } catch (std::out_of_range& e) {
95229       {
95230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95231       };
95232     } catch (std::exception& e) {
95233       {
95234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95235       };
95236     } catch (Dali::DaliException e) {
95237       {
95238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95239       };
95240     } catch (...) {
95241       {
95242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95243       };
95244     }
95245   }
95246
95247   jresult = result;
95248   return jresult;
95249 }
95250
95251
95252 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95253   unsigned long jresult ;
95254   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95255   std::size_t result;
95256
95257   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95258   {
95259     try {
95260       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);
95261     } catch (std::out_of_range& e) {
95262       {
95263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95264       };
95265     } catch (std::exception& e) {
95266       {
95267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95268       };
95269     } catch (Dali::DaliException e) {
95270       {
95271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95272       };
95273     } catch (...) {
95274       {
95275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95276       };
95277     }
95278   }
95279
95280   jresult = (unsigned long)result;
95281   return jresult;
95282 }
95283
95284
95285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95286   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95287   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95288
95289   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95290   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95291   {
95292     try {
95293       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95294     } catch (std::out_of_range& e) {
95295       {
95296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95297       };
95298     } catch (std::exception& e) {
95299       {
95300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95301       };
95302     } catch (Dali::DaliException e) {
95303       {
95304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95305       };
95306     } catch (...) {
95307       {
95308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95309       };
95310     }
95311   }
95312
95313 }
95314
95315
95316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95317   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95318   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95319
95320   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95321   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95322   {
95323     try {
95324       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95325     } catch (std::out_of_range& e) {
95326       {
95327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95328       };
95329     } catch (std::exception& e) {
95330       {
95331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95332       };
95333     } catch (Dali::DaliException e) {
95334       {
95335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95336       };
95337     } catch (...) {
95338       {
95339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95340       };
95341     }
95342   }
95343
95344 }
95345
95346
95347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95348   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95349   Dali::Actor arg2 ;
95350   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95351   Dali::Actor *argp2 ;
95352
95353   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95354   argp2 = (Dali::Actor *)jarg2;
95355   if (!argp2) {
95356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95357     return ;
95358   }
95359   arg2 = *argp2;
95360   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95361   {
95362     try {
95363       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95364     } catch (std::out_of_range& e) {
95365       {
95366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95367       };
95368     } catch (std::exception& e) {
95369       {
95370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95371       };
95372     } catch (Dali::DaliException e) {
95373       {
95374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95375       };
95376     } catch (...) {
95377       {
95378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95379       };
95380     }
95381   }
95382
95383 }
95384
95385
95386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95387   void * jresult ;
95388   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95389
95390   {
95391     try {
95392       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95393     } catch (std::out_of_range& e) {
95394       {
95395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95396       };
95397     } catch (std::exception& e) {
95398       {
95399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95400       };
95401     } catch (Dali::DaliException e) {
95402       {
95403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95404       };
95405     } catch (...) {
95406       {
95407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95408       };
95409     }
95410   }
95411
95412   jresult = (void *)result;
95413   return jresult;
95414 }
95415
95416
95417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95418   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95419
95420   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95421   {
95422     try {
95423       delete arg1;
95424     } catch (std::out_of_range& e) {
95425       {
95426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95427       };
95428     } catch (std::exception& e) {
95429       {
95430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95431       };
95432     } catch (Dali::DaliException e) {
95433       {
95434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95435       };
95436     } catch (...) {
95437       {
95438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95439       };
95440     }
95441   }
95442
95443 }
95444
95445
95446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95447   unsigned int jresult ;
95448   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95449   bool result;
95450
95451   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95452   {
95453     try {
95454       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95455     } catch (std::out_of_range& e) {
95456       {
95457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95458       };
95459     } catch (std::exception& e) {
95460       {
95461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95462       };
95463     } catch (Dali::DaliException e) {
95464       {
95465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95466       };
95467     } catch (...) {
95468       {
95469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95470       };
95471     }
95472   }
95473
95474   jresult = result;
95475   return jresult;
95476 }
95477
95478
95479 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95480   unsigned long jresult ;
95481   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95482   std::size_t result;
95483
95484   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95485   {
95486     try {
95487       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95488     } catch (std::out_of_range& e) {
95489       {
95490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95491       };
95492     } catch (std::exception& e) {
95493       {
95494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95495       };
95496     } catch (Dali::DaliException e) {
95497       {
95498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95499       };
95500     } catch (...) {
95501       {
95502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95503       };
95504     }
95505   }
95506
95507   jresult = (unsigned long)result;
95508   return jresult;
95509 }
95510
95511
95512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95513   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95514   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95515
95516   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95517   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95518   {
95519     try {
95520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95521     } catch (std::out_of_range& e) {
95522       {
95523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95524       };
95525     } catch (std::exception& e) {
95526       {
95527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95528       };
95529     } catch (Dali::DaliException e) {
95530       {
95531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95532       };
95533     } catch (...) {
95534       {
95535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95536       };
95537     }
95538   }
95539
95540 }
95541
95542
95543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95544   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95545   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95546
95547   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95548   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95549   {
95550     try {
95551       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95552     } catch (std::out_of_range& e) {
95553       {
95554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95555       };
95556     } catch (std::exception& e) {
95557       {
95558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95559       };
95560     } catch (Dali::DaliException e) {
95561       {
95562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95563       };
95564     } catch (...) {
95565       {
95566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95567       };
95568     }
95569   }
95570
95571 }
95572
95573
95574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95575   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95576   Dali::Actor arg2 ;
95577   Dali::Actor arg3 ;
95578   Dali::Actor *argp2 ;
95579   Dali::Actor *argp3 ;
95580
95581   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95582   argp2 = (Dali::Actor *)jarg2;
95583   if (!argp2) {
95584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95585     return ;
95586   }
95587   arg2 = *argp2;
95588   argp3 = (Dali::Actor *)jarg3;
95589   if (!argp3) {
95590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95591     return ;
95592   }
95593   arg3 = *argp3;
95594   {
95595     try {
95596       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95597     } catch (std::out_of_range& e) {
95598       {
95599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95600       };
95601     } catch (std::exception& e) {
95602       {
95603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95604       };
95605     } catch (Dali::DaliException e) {
95606       {
95607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95608       };
95609     } catch (...) {
95610       {
95611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95612       };
95613     }
95614   }
95615
95616 }
95617
95618
95619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95620   void * jresult ;
95621   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95622
95623   {
95624     try {
95625       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95626     } catch (std::out_of_range& e) {
95627       {
95628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95629       };
95630     } catch (std::exception& e) {
95631       {
95632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95633       };
95634     } catch (Dali::DaliException e) {
95635       {
95636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95637       };
95638     } catch (...) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95641       };
95642     }
95643   }
95644
95645   jresult = (void *)result;
95646   return jresult;
95647 }
95648
95649
95650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95651   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95652
95653   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95654   {
95655     try {
95656       delete arg1;
95657     } catch (std::out_of_range& e) {
95658       {
95659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95660       };
95661     } catch (std::exception& e) {
95662       {
95663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95664       };
95665     } catch (Dali::DaliException e) {
95666       {
95667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95668       };
95669     } catch (...) {
95670       {
95671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95672       };
95673     }
95674   }
95675
95676 }
95677
95678
95679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95680   unsigned int jresult ;
95681   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95682   bool result;
95683
95684   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95685   {
95686     try {
95687       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95688     } catch (std::out_of_range& e) {
95689       {
95690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95691       };
95692     } catch (std::exception& e) {
95693       {
95694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95695       };
95696     } catch (Dali::DaliException e) {
95697       {
95698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95699       };
95700     } catch (...) {
95701       {
95702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95703       };
95704     }
95705   }
95706
95707   jresult = result;
95708   return jresult;
95709 }
95710
95711
95712 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95713   unsigned long jresult ;
95714   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95715   std::size_t result;
95716
95717   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95718   {
95719     try {
95720       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95721     } catch (std::out_of_range& e) {
95722       {
95723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95724       };
95725     } catch (std::exception& e) {
95726       {
95727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95728       };
95729     } catch (Dali::DaliException e) {
95730       {
95731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95732       };
95733     } catch (...) {
95734       {
95735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95736       };
95737     }
95738   }
95739
95740   jresult = (unsigned long)result;
95741   return jresult;
95742 }
95743
95744
95745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95746   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95747   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95748
95749   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95750   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95751   {
95752     try {
95753       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95754     } catch (std::out_of_range& e) {
95755       {
95756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95757       };
95758     } catch (std::exception& e) {
95759       {
95760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95761       };
95762     } catch (Dali::DaliException e) {
95763       {
95764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95765       };
95766     } catch (...) {
95767       {
95768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95769       };
95770     }
95771   }
95772
95773 }
95774
95775
95776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95777   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95778   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95779
95780   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95781   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95782   {
95783     try {
95784       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95785     } catch (std::out_of_range& e) {
95786       {
95787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95788       };
95789     } catch (std::exception& e) {
95790       {
95791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95792       };
95793     } catch (Dali::DaliException e) {
95794       {
95795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95796       };
95797     } catch (...) {
95798       {
95799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95800       };
95801     }
95802   }
95803
95804 }
95805
95806
95807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95808   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95809   Dali::Actor arg2 ;
95810   bool arg3 ;
95811   Dali::Actor *argp2 ;
95812
95813   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95814   argp2 = (Dali::Actor *)jarg2;
95815   if (!argp2) {
95816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95817     return ;
95818   }
95819   arg2 = *argp2;
95820   arg3 = jarg3 ? true : false;
95821   {
95822     try {
95823       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95824     } catch (std::out_of_range& e) {
95825       {
95826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95827       };
95828     } catch (std::exception& e) {
95829       {
95830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95831       };
95832     } catch (Dali::DaliException e) {
95833       {
95834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95835       };
95836     } catch (...) {
95837       {
95838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95839       };
95840     }
95841   }
95842
95843 }
95844
95845
95846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95847   void * jresult ;
95848   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95849
95850   {
95851     try {
95852       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95853     } catch (std::out_of_range& e) {
95854       {
95855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95856       };
95857     } catch (std::exception& e) {
95858       {
95859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95860       };
95861     } catch (Dali::DaliException e) {
95862       {
95863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95864       };
95865     } catch (...) {
95866       {
95867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95868       };
95869     }
95870   }
95871
95872   jresult = (void *)result;
95873   return jresult;
95874 }
95875
95876
95877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95878   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95879
95880   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95881   {
95882     try {
95883       delete arg1;
95884     } catch (std::out_of_range& e) {
95885       {
95886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95887       };
95888     } catch (std::exception& e) {
95889       {
95890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95891       };
95892     } catch (Dali::DaliException e) {
95893       {
95894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95895       };
95896     } catch (...) {
95897       {
95898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95899       };
95900     }
95901   }
95902
95903 }
95904
95905
95906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95907   unsigned int jresult ;
95908   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95909   bool result;
95910
95911   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95912   {
95913     try {
95914       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);
95915     } catch (std::out_of_range& e) {
95916       {
95917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95918       };
95919     } catch (std::exception& e) {
95920       {
95921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95922       };
95923     } catch (Dali::DaliException e) {
95924       {
95925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95926       };
95927     } catch (...) {
95928       {
95929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95930       };
95931     }
95932   }
95933
95934   jresult = result;
95935   return jresult;
95936 }
95937
95938
95939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95940   unsigned long jresult ;
95941   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95942   std::size_t result;
95943
95944   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95945   {
95946     try {
95947       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);
95948     } catch (std::out_of_range& e) {
95949       {
95950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95951       };
95952     } catch (std::exception& e) {
95953       {
95954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95955       };
95956     } catch (Dali::DaliException e) {
95957       {
95958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95959       };
95960     } catch (...) {
95961       {
95962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95963       };
95964     }
95965   }
95966
95967   jresult = (unsigned long)result;
95968   return jresult;
95969 }
95970
95971
95972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95973   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95974   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95975
95976   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95977   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95978   {
95979     try {
95980       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95981     } catch (std::out_of_range& e) {
95982       {
95983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95984       };
95985     } catch (std::exception& e) {
95986       {
95987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95988       };
95989     } catch (Dali::DaliException e) {
95990       {
95991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95992       };
95993     } catch (...) {
95994       {
95995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95996       };
95997     }
95998   }
95999
96000 }
96001
96002
96003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96004   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96005   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96006
96007   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96008   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96009   {
96010     try {
96011       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96012     } catch (std::out_of_range& e) {
96013       {
96014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96015       };
96016     } catch (std::exception& e) {
96017       {
96018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96019       };
96020     } catch (Dali::DaliException e) {
96021       {
96022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96023       };
96024     } catch (...) {
96025       {
96026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96027       };
96028     }
96029   }
96030
96031 }
96032
96033
96034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96035   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96036   Dali::Toolkit::StyleManager arg2 ;
96037   Dali::StyleChange::Type arg3 ;
96038   Dali::Toolkit::StyleManager *argp2 ;
96039
96040   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96041   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96042   if (!argp2) {
96043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96044     return ;
96045   }
96046   arg2 = *argp2;
96047   arg3 = (Dali::StyleChange::Type)jarg3;
96048   {
96049     try {
96050       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96051     } catch (std::out_of_range& e) {
96052       {
96053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96054       };
96055     } catch (std::exception& e) {
96056       {
96057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96058       };
96059     } catch (Dali::DaliException e) {
96060       {
96061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96062       };
96063     } catch (...) {
96064       {
96065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96066       };
96067     }
96068   }
96069
96070 }
96071
96072
96073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96074   void * jresult ;
96075   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96076
96077   {
96078     try {
96079       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96080     } catch (std::out_of_range& e) {
96081       {
96082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96083       };
96084     } catch (std::exception& e) {
96085       {
96086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96087       };
96088     } catch (Dali::DaliException e) {
96089       {
96090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96091       };
96092     } catch (...) {
96093       {
96094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96095       };
96096     }
96097   }
96098
96099   jresult = (void *)result;
96100   return jresult;
96101 }
96102
96103
96104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96105   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96106
96107   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96108   {
96109     try {
96110       delete arg1;
96111     } catch (std::out_of_range& e) {
96112       {
96113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96114       };
96115     } catch (std::exception& e) {
96116       {
96117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96118       };
96119     } catch (Dali::DaliException e) {
96120       {
96121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96122       };
96123     } catch (...) {
96124       {
96125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96126       };
96127     }
96128   }
96129
96130 }
96131
96132
96133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96134   unsigned int jresult ;
96135   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96136   bool result;
96137
96138   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96139   {
96140     try {
96141       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96142     } catch (std::out_of_range& e) {
96143       {
96144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96145       };
96146     } catch (std::exception& e) {
96147       {
96148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96149       };
96150     } catch (Dali::DaliException e) {
96151       {
96152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96153       };
96154     } catch (...) {
96155       {
96156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96157       };
96158     }
96159   }
96160
96161   jresult = result;
96162   return jresult;
96163 }
96164
96165
96166 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96167   unsigned long jresult ;
96168   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96169   std::size_t result;
96170
96171   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96172   {
96173     try {
96174       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96175     } catch (std::out_of_range& e) {
96176       {
96177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96178       };
96179     } catch (std::exception& e) {
96180       {
96181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96182       };
96183     } catch (Dali::DaliException e) {
96184       {
96185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96186       };
96187     } catch (...) {
96188       {
96189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96190       };
96191     }
96192   }
96193
96194   jresult = (unsigned long)result;
96195   return jresult;
96196 }
96197
96198
96199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96200   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96201   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96202
96203   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96204   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96205   {
96206     try {
96207       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96208     } catch (std::out_of_range& e) {
96209       {
96210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96211       };
96212     } catch (std::exception& e) {
96213       {
96214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96215       };
96216     } catch (Dali::DaliException e) {
96217       {
96218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96219       };
96220     } catch (...) {
96221       {
96222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96223       };
96224     }
96225   }
96226
96227 }
96228
96229
96230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96231   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96232   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96233
96234   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96235   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96236   {
96237     try {
96238       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96239     } catch (std::out_of_range& e) {
96240       {
96241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96242       };
96243     } catch (std::exception& e) {
96244       {
96245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96246       };
96247     } catch (Dali::DaliException e) {
96248       {
96249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96250       };
96251     } catch (...) {
96252       {
96253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96254       };
96255     }
96256   }
96257
96258 }
96259
96260
96261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96262   unsigned int jresult ;
96263   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96264   Dali::Toolkit::Button arg2 ;
96265   Dali::Toolkit::Button *argp2 ;
96266   bool result;
96267
96268   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96269   argp2 = (Dali::Toolkit::Button *)jarg2;
96270   if (!argp2) {
96271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96272     return 0;
96273   }
96274   arg2 = *argp2;
96275   {
96276     try {
96277       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96278     } catch (std::out_of_range& e) {
96279       {
96280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96281       };
96282     } catch (std::exception& e) {
96283       {
96284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96285       };
96286     } catch (Dali::DaliException e) {
96287       {
96288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96289       };
96290     } catch (...) {
96291       {
96292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96293       };
96294     }
96295   }
96296
96297   jresult = result;
96298   return jresult;
96299 }
96300
96301
96302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96303   void * jresult ;
96304   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96305
96306   {
96307     try {
96308       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96309     } catch (std::out_of_range& e) {
96310       {
96311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96312       };
96313     } catch (std::exception& e) {
96314       {
96315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96316       };
96317     } catch (Dali::DaliException e) {
96318       {
96319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96320       };
96321     } catch (...) {
96322       {
96323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96324       };
96325     }
96326   }
96327
96328   jresult = (void *)result;
96329   return jresult;
96330 }
96331
96332
96333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96334   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96335
96336   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96337   {
96338     try {
96339       delete arg1;
96340     } catch (std::out_of_range& e) {
96341       {
96342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96343       };
96344     } catch (std::exception& e) {
96345       {
96346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96347       };
96348     } catch (Dali::DaliException e) {
96349       {
96350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96351       };
96352     } catch (...) {
96353       {
96354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96355       };
96356     }
96357   }
96358
96359 }
96360
96361
96362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96363   unsigned int jresult ;
96364   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96365   bool result;
96366
96367   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96368   {
96369     try {
96370       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96371     } catch (std::out_of_range& e) {
96372       {
96373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96374       };
96375     } catch (std::exception& e) {
96376       {
96377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96378       };
96379     } catch (Dali::DaliException e) {
96380       {
96381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96382       };
96383     } catch (...) {
96384       {
96385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96386       };
96387     }
96388   }
96389
96390   jresult = result;
96391   return jresult;
96392 }
96393
96394
96395 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96396   unsigned long jresult ;
96397   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96398   std::size_t result;
96399
96400   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96401   {
96402     try {
96403       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96404     } catch (std::out_of_range& e) {
96405       {
96406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96407       };
96408     } catch (std::exception& e) {
96409       {
96410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96411       };
96412     } catch (Dali::DaliException e) {
96413       {
96414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96415       };
96416     } catch (...) {
96417       {
96418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96419       };
96420     }
96421   }
96422
96423   jresult = (unsigned long)result;
96424   return jresult;
96425 }
96426
96427
96428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96429   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96430   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96431
96432   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96433   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96434   {
96435     try {
96436       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96437     } catch (std::out_of_range& e) {
96438       {
96439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96440       };
96441     } catch (std::exception& e) {
96442       {
96443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96444       };
96445     } catch (Dali::DaliException e) {
96446       {
96447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96448       };
96449     } catch (...) {
96450       {
96451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96452       };
96453     }
96454   }
96455
96456 }
96457
96458
96459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96460   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96461   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96462
96463   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96464   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96465   {
96466     try {
96467       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96468     } catch (std::out_of_range& e) {
96469       {
96470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96471       };
96472     } catch (std::exception& e) {
96473       {
96474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96475       };
96476     } catch (Dali::DaliException e) {
96477       {
96478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96479       };
96480     } catch (...) {
96481       {
96482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96483       };
96484     }
96485   }
96486
96487 }
96488
96489
96490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96491   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96492   Dali::Toolkit::GaussianBlurView arg2 ;
96493   Dali::Toolkit::GaussianBlurView *argp2 ;
96494
96495   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96496   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96497   if (!argp2) {
96498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96499     return ;
96500   }
96501   arg2 = *argp2;
96502   {
96503     try {
96504       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96505     } catch (std::out_of_range& e) {
96506       {
96507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96508       };
96509     } catch (std::exception& e) {
96510       {
96511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96512       };
96513     } catch (Dali::DaliException e) {
96514       {
96515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96516       };
96517     } catch (...) {
96518       {
96519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96520       };
96521     }
96522   }
96523
96524 }
96525
96526
96527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96528   void * jresult ;
96529   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96530
96531   {
96532     try {
96533       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96534     } catch (std::out_of_range& e) {
96535       {
96536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96537       };
96538     } catch (std::exception& e) {
96539       {
96540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96541       };
96542     } catch (Dali::DaliException e) {
96543       {
96544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96545       };
96546     } catch (...) {
96547       {
96548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96549       };
96550     }
96551   }
96552
96553   jresult = (void *)result;
96554   return jresult;
96555 }
96556
96557
96558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96559   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96560
96561   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96562   {
96563     try {
96564       delete arg1;
96565     } catch (std::out_of_range& e) {
96566       {
96567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96568       };
96569     } catch (std::exception& e) {
96570       {
96571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96572       };
96573     } catch (Dali::DaliException e) {
96574       {
96575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96576       };
96577     } catch (...) {
96578       {
96579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96580       };
96581     }
96582   }
96583
96584 }
96585
96586
96587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96588   unsigned int jresult ;
96589   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96590   bool result;
96591
96592   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96593   {
96594     try {
96595       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);
96596     } catch (std::out_of_range& e) {
96597       {
96598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96599       };
96600     } catch (std::exception& e) {
96601       {
96602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96603       };
96604     } catch (Dali::DaliException e) {
96605       {
96606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96607       };
96608     } catch (...) {
96609       {
96610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96611       };
96612     }
96613   }
96614
96615   jresult = result;
96616   return jresult;
96617 }
96618
96619
96620 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96621   unsigned long jresult ;
96622   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96623   std::size_t result;
96624
96625   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96626   {
96627     try {
96628       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);
96629     } catch (std::out_of_range& e) {
96630       {
96631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96632       };
96633     } catch (std::exception& e) {
96634       {
96635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96636       };
96637     } catch (Dali::DaliException e) {
96638       {
96639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96640       };
96641     } catch (...) {
96642       {
96643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96644       };
96645     }
96646   }
96647
96648   jresult = (unsigned long)result;
96649   return jresult;
96650 }
96651
96652
96653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96654   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96655   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96656
96657   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96658   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96659   {
96660     try {
96661       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96662     } catch (std::out_of_range& e) {
96663       {
96664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96665       };
96666     } catch (std::exception& e) {
96667       {
96668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96669       };
96670     } catch (Dali::DaliException e) {
96671       {
96672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96673       };
96674     } catch (...) {
96675       {
96676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96677       };
96678     }
96679   }
96680
96681 }
96682
96683
96684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96685   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96686   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96687
96688   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96689   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96690   {
96691     try {
96692       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96693     } catch (std::out_of_range& e) {
96694       {
96695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96696       };
96697     } catch (std::exception& e) {
96698       {
96699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96700       };
96701     } catch (Dali::DaliException e) {
96702       {
96703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96704       };
96705     } catch (...) {
96706       {
96707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96708       };
96709     }
96710   }
96711
96712 }
96713
96714
96715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96716   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96717   Dali::Toolkit::PageTurnView arg2 ;
96718   unsigned int arg3 ;
96719   bool arg4 ;
96720   Dali::Toolkit::PageTurnView *argp2 ;
96721
96722   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96723   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96724   if (!argp2) {
96725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96726     return ;
96727   }
96728   arg2 = *argp2;
96729   arg3 = (unsigned int)jarg3;
96730   arg4 = jarg4 ? true : false;
96731   {
96732     try {
96733       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96734     } catch (std::out_of_range& e) {
96735       {
96736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96737       };
96738     } catch (std::exception& e) {
96739       {
96740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96741       };
96742     } catch (Dali::DaliException e) {
96743       {
96744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96745       };
96746     } catch (...) {
96747       {
96748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96749       };
96750     }
96751   }
96752
96753 }
96754
96755
96756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96757   void * jresult ;
96758   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96759
96760   {
96761     try {
96762       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96763     } catch (std::out_of_range& e) {
96764       {
96765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96766       };
96767     } catch (std::exception& e) {
96768       {
96769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96770       };
96771     } catch (Dali::DaliException e) {
96772       {
96773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96774       };
96775     } catch (...) {
96776       {
96777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96778       };
96779     }
96780   }
96781
96782   jresult = (void *)result;
96783   return jresult;
96784 }
96785
96786
96787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96788   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96789
96790   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96791   {
96792     try {
96793       delete arg1;
96794     } catch (std::out_of_range& e) {
96795       {
96796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96797       };
96798     } catch (std::exception& e) {
96799       {
96800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96801       };
96802     } catch (Dali::DaliException e) {
96803       {
96804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96805       };
96806     } catch (...) {
96807       {
96808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96809       };
96810     }
96811   }
96812
96813 }
96814
96815
96816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96817   unsigned int jresult ;
96818   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96819   bool result;
96820
96821   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96822   {
96823     try {
96824       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96825     } catch (std::out_of_range& e) {
96826       {
96827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96828       };
96829     } catch (std::exception& e) {
96830       {
96831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96832       };
96833     } catch (Dali::DaliException e) {
96834       {
96835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96836       };
96837     } catch (...) {
96838       {
96839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96840       };
96841     }
96842   }
96843
96844   jresult = result;
96845   return jresult;
96846 }
96847
96848
96849 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96850   unsigned long jresult ;
96851   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96852   std::size_t result;
96853
96854   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96855   {
96856     try {
96857       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96858     } catch (std::out_of_range& e) {
96859       {
96860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96861       };
96862     } catch (std::exception& e) {
96863       {
96864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96865       };
96866     } catch (Dali::DaliException e) {
96867       {
96868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96869       };
96870     } catch (...) {
96871       {
96872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96873       };
96874     }
96875   }
96876
96877   jresult = (unsigned long)result;
96878   return jresult;
96879 }
96880
96881
96882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96883   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96884   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96885
96886   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96887   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96888   {
96889     try {
96890       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96891     } catch (std::out_of_range& e) {
96892       {
96893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96894       };
96895     } catch (std::exception& e) {
96896       {
96897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96898       };
96899     } catch (Dali::DaliException e) {
96900       {
96901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96902       };
96903     } catch (...) {
96904       {
96905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96906       };
96907     }
96908   }
96909
96910 }
96911
96912
96913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96914   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96915   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96916
96917   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96918   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96919   {
96920     try {
96921       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96922     } catch (std::out_of_range& e) {
96923       {
96924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96925       };
96926     } catch (std::exception& e) {
96927       {
96928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96929       };
96930     } catch (Dali::DaliException e) {
96931       {
96932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96933       };
96934     } catch (...) {
96935       {
96936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96937       };
96938     }
96939   }
96940
96941 }
96942
96943
96944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96945   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96946   Dali::Toolkit::PageTurnView arg2 ;
96947   Dali::Toolkit::PageTurnView *argp2 ;
96948
96949   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96950   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96951   if (!argp2) {
96952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96953     return ;
96954   }
96955   arg2 = *argp2;
96956   {
96957     try {
96958       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96959     } catch (std::out_of_range& e) {
96960       {
96961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96962       };
96963     } catch (std::exception& e) {
96964       {
96965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96966       };
96967     } catch (Dali::DaliException e) {
96968       {
96969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96970       };
96971     } catch (...) {
96972       {
96973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96974       };
96975     }
96976   }
96977
96978 }
96979
96980
96981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96982   void * jresult ;
96983   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96984
96985   {
96986     try {
96987       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96988     } catch (std::out_of_range& e) {
96989       {
96990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96991       };
96992     } catch (std::exception& e) {
96993       {
96994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96995       };
96996     } catch (Dali::DaliException e) {
96997       {
96998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96999       };
97000     } catch (...) {
97001       {
97002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97003       };
97004     }
97005   }
97006
97007   jresult = (void *)result;
97008   return jresult;
97009 }
97010
97011
97012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97013   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97014
97015   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97016   {
97017     try {
97018       delete arg1;
97019     } catch (std::out_of_range& e) {
97020       {
97021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97022       };
97023     } catch (std::exception& e) {
97024       {
97025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97026       };
97027     } catch (Dali::DaliException e) {
97028       {
97029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97030       };
97031     } catch (...) {
97032       {
97033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97034       };
97035     }
97036   }
97037
97038 }
97039
97040
97041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97042   unsigned int jresult ;
97043   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97044   bool result;
97045
97046   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97047   {
97048     try {
97049       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);
97050     } catch (std::out_of_range& e) {
97051       {
97052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97053       };
97054     } catch (std::exception& e) {
97055       {
97056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97057       };
97058     } catch (Dali::DaliException e) {
97059       {
97060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97061       };
97062     } catch (...) {
97063       {
97064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97065       };
97066     }
97067   }
97068
97069   jresult = result;
97070   return jresult;
97071 }
97072
97073
97074 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97075   unsigned long jresult ;
97076   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97077   std::size_t result;
97078
97079   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97080   {
97081     try {
97082       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);
97083     } catch (std::out_of_range& e) {
97084       {
97085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97086       };
97087     } catch (std::exception& e) {
97088       {
97089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97090       };
97091     } catch (Dali::DaliException e) {
97092       {
97093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97094       };
97095     } catch (...) {
97096       {
97097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97098       };
97099     }
97100   }
97101
97102   jresult = (unsigned long)result;
97103   return jresult;
97104 }
97105
97106
97107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97108   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97109   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97110
97111   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97112   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97113   {
97114     try {
97115       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97116     } catch (std::out_of_range& e) {
97117       {
97118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97119       };
97120     } catch (std::exception& e) {
97121       {
97122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97123       };
97124     } catch (Dali::DaliException e) {
97125       {
97126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97127       };
97128     } catch (...) {
97129       {
97130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97131       };
97132     }
97133   }
97134
97135 }
97136
97137
97138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97139   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97140   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97141
97142   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97143   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97144   {
97145     try {
97146       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97147     } catch (std::out_of_range& e) {
97148       {
97149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97150       };
97151     } catch (std::exception& e) {
97152       {
97153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97154       };
97155     } catch (Dali::DaliException e) {
97156       {
97157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97158       };
97159     } catch (...) {
97160       {
97161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97162       };
97163     }
97164   }
97165
97166 }
97167
97168
97169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97170   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97171   Dali::Toolkit::ProgressBar arg2 ;
97172   float arg3 ;
97173   float arg4 ;
97174   Dali::Toolkit::ProgressBar *argp2 ;
97175
97176   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97177   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97178   if (!argp2) {
97179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97180     return ;
97181   }
97182   arg2 = *argp2;
97183   arg3 = (float)jarg3;
97184   arg4 = (float)jarg4;
97185   {
97186     try {
97187       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97188     } catch (std::out_of_range& e) {
97189       {
97190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97191       };
97192     } catch (std::exception& e) {
97193       {
97194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97195       };
97196     } catch (Dali::DaliException e) {
97197       {
97198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97199       };
97200     } catch (...) {
97201       {
97202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97203       };
97204     }
97205   }
97206
97207 }
97208
97209
97210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97211   void * jresult ;
97212   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97213
97214   {
97215     try {
97216       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97217     } catch (std::out_of_range& e) {
97218       {
97219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97220       };
97221     } catch (std::exception& e) {
97222       {
97223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97224       };
97225     } catch (Dali::DaliException e) {
97226       {
97227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97228       };
97229     } catch (...) {
97230       {
97231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97232       };
97233     }
97234   }
97235
97236   jresult = (void *)result;
97237   return jresult;
97238 }
97239
97240
97241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97242   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97243
97244   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97245   {
97246     try {
97247       delete arg1;
97248     } catch (std::out_of_range& e) {
97249       {
97250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97251       };
97252     } catch (std::exception& e) {
97253       {
97254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97255       };
97256     } catch (Dali::DaliException e) {
97257       {
97258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97259       };
97260     } catch (...) {
97261       {
97262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97263       };
97264     }
97265   }
97266
97267 }
97268
97269
97270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97271   unsigned int jresult ;
97272   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97273   bool result;
97274
97275   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97276   {
97277     try {
97278       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);
97279     } catch (std::out_of_range& e) {
97280       {
97281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97282       };
97283     } catch (std::exception& e) {
97284       {
97285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97286       };
97287     } catch (Dali::DaliException e) {
97288       {
97289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97290       };
97291     } catch (...) {
97292       {
97293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97294       };
97295     }
97296   }
97297
97298   jresult = result;
97299   return jresult;
97300 }
97301
97302
97303 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97304   unsigned long jresult ;
97305   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97306   std::size_t result;
97307
97308   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97309   {
97310     try {
97311       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);
97312     } catch (std::out_of_range& e) {
97313       {
97314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97315       };
97316     } catch (std::exception& e) {
97317       {
97318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97319       };
97320     } catch (Dali::DaliException e) {
97321       {
97322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97323       };
97324     } catch (...) {
97325       {
97326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97327       };
97328     }
97329   }
97330
97331   jresult = (unsigned long)result;
97332   return jresult;
97333 }
97334
97335
97336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97337   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97338   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97339
97340   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97341   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97342   {
97343     try {
97344       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97345     } catch (std::out_of_range& e) {
97346       {
97347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97348       };
97349     } catch (std::exception& e) {
97350       {
97351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97352       };
97353     } catch (Dali::DaliException e) {
97354       {
97355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97356       };
97357     } catch (...) {
97358       {
97359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97360       };
97361     }
97362   }
97363
97364 }
97365
97366
97367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97368   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97369   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97370
97371   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97372   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97373   {
97374     try {
97375       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97376     } catch (std::out_of_range& e) {
97377       {
97378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97379       };
97380     } catch (std::exception& e) {
97381       {
97382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97383       };
97384     } catch (Dali::DaliException e) {
97385       {
97386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97387       };
97388     } catch (...) {
97389       {
97390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97391       };
97392     }
97393   }
97394
97395 }
97396
97397
97398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97399   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97400   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97401
97402   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97403   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97404   if (!arg2) {
97405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97406     return ;
97407   }
97408   {
97409     try {
97410       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97411     } catch (std::out_of_range& e) {
97412       {
97413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97414       };
97415     } catch (std::exception& e) {
97416       {
97417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97418       };
97419     } catch (Dali::DaliException e) {
97420       {
97421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97422       };
97423     } catch (...) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97426       };
97427     }
97428   }
97429
97430 }
97431
97432
97433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97434   void * jresult ;
97435   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97436
97437   {
97438     try {
97439       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97440     } catch (std::out_of_range& e) {
97441       {
97442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97443       };
97444     } catch (std::exception& e) {
97445       {
97446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97447       };
97448     } catch (Dali::DaliException e) {
97449       {
97450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97451       };
97452     } catch (...) {
97453       {
97454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97455       };
97456     }
97457   }
97458
97459   jresult = (void *)result;
97460   return jresult;
97461 }
97462
97463
97464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97465   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97466
97467   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97468   {
97469     try {
97470       delete arg1;
97471     } catch (std::out_of_range& e) {
97472       {
97473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97474       };
97475     } catch (std::exception& e) {
97476       {
97477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97478       };
97479     } catch (Dali::DaliException e) {
97480       {
97481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97482       };
97483     } catch (...) {
97484       {
97485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97486       };
97487     }
97488   }
97489
97490 }
97491
97492
97493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97494   unsigned int jresult ;
97495   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97496   bool result;
97497
97498   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97499   {
97500     try {
97501       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97502     } catch (std::out_of_range& e) {
97503       {
97504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97505       };
97506     } catch (std::exception& e) {
97507       {
97508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97509       };
97510     } catch (Dali::DaliException e) {
97511       {
97512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97513       };
97514     } catch (...) {
97515       {
97516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97517       };
97518     }
97519   }
97520
97521   jresult = result;
97522   return jresult;
97523 }
97524
97525
97526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97527   unsigned long jresult ;
97528   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97529   std::size_t result;
97530
97531   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97532   {
97533     try {
97534       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97535     } catch (std::out_of_range& e) {
97536       {
97537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97538       };
97539     } catch (std::exception& e) {
97540       {
97541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97542       };
97543     } catch (Dali::DaliException e) {
97544       {
97545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97546       };
97547     } catch (...) {
97548       {
97549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97550       };
97551     }
97552   }
97553
97554   jresult = (unsigned long)result;
97555   return jresult;
97556 }
97557
97558
97559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97560   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97561   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97562
97563   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97564   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97565   {
97566     try {
97567       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97568     } catch (std::out_of_range& e) {
97569       {
97570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97571       };
97572     } catch (std::exception& e) {
97573       {
97574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97575       };
97576     } catch (Dali::DaliException e) {
97577       {
97578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97579       };
97580     } catch (...) {
97581       {
97582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97583       };
97584     }
97585   }
97586
97587 }
97588
97589
97590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97591   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97592   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97593
97594   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97595   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97596   {
97597     try {
97598       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97599     } catch (std::out_of_range& e) {
97600       {
97601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97602       };
97603     } catch (std::exception& e) {
97604       {
97605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97606       };
97607     } catch (Dali::DaliException e) {
97608       {
97609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97610       };
97611     } catch (...) {
97612       {
97613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97614       };
97615     }
97616   }
97617
97618 }
97619
97620
97621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97622   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97623   Dali::Vector2 *arg2 = 0 ;
97624
97625   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97626   arg2 = (Dali::Vector2 *)jarg2;
97627   if (!arg2) {
97628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97629     return ;
97630   }
97631   {
97632     try {
97633       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97634     } catch (std::out_of_range& e) {
97635       {
97636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97637       };
97638     } catch (std::exception& e) {
97639       {
97640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97641       };
97642     } catch (Dali::DaliException e) {
97643       {
97644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97645       };
97646     } catch (...) {
97647       {
97648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97649       };
97650     }
97651   }
97652
97653 }
97654
97655
97656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97657   void * jresult ;
97658   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97659
97660   {
97661     try {
97662       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97663     } catch (std::out_of_range& e) {
97664       {
97665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97666       };
97667     } catch (std::exception& e) {
97668       {
97669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97670       };
97671     } catch (Dali::DaliException e) {
97672       {
97673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97674       };
97675     } catch (...) {
97676       {
97677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97678       };
97679     }
97680   }
97681
97682   jresult = (void *)result;
97683   return jresult;
97684 }
97685
97686
97687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97688   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97689
97690   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97691   {
97692     try {
97693       delete arg1;
97694     } catch (std::out_of_range& e) {
97695       {
97696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97697       };
97698     } catch (std::exception& e) {
97699       {
97700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97701       };
97702     } catch (Dali::DaliException e) {
97703       {
97704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97705       };
97706     } catch (...) {
97707       {
97708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97709       };
97710     }
97711   }
97712
97713 }
97714
97715
97716
97717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97718   unsigned int jresult ;
97719   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97720   bool result;
97721
97722   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97723   {
97724     try {
97725       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);
97726     } catch (std::out_of_range& e) {
97727       {
97728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97729       };
97730     } catch (std::exception& e) {
97731       {
97732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97733       };
97734     } catch (Dali::DaliException e) {
97735       {
97736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97737       };
97738     } catch (...) {
97739       {
97740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97741       };
97742     }
97743   }
97744
97745   jresult = result;
97746   return jresult;
97747 }
97748
97749
97750 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97751   unsigned long jresult ;
97752   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97753   std::size_t result;
97754
97755   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97756   {
97757     try {
97758       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);
97759     } catch (std::out_of_range& e) {
97760       {
97761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97762       };
97763     } catch (std::exception& e) {
97764       {
97765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97766       };
97767     } catch (Dali::DaliException e) {
97768       {
97769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97770       };
97771     } catch (...) {
97772       {
97773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97774       };
97775     }
97776   }
97777
97778   jresult = (unsigned long)result;
97779   return jresult;
97780 }
97781
97782
97783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97784   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97785   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97786
97787   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97788   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97789   {
97790     try {
97791       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97792     } catch (std::out_of_range& e) {
97793       {
97794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97795       };
97796     } catch (std::exception& e) {
97797       {
97798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97799       };
97800     } catch (Dali::DaliException e) {
97801       {
97802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97803       };
97804     } catch (...) {
97805       {
97806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97807       };
97808     }
97809   }
97810
97811 }
97812
97813
97814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97815   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97816   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97817
97818   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97819   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97820   {
97821     try {
97822       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97823     } catch (std::out_of_range& e) {
97824       {
97825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97826       };
97827     } catch (std::exception& e) {
97828       {
97829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97830       };
97831     } catch (Dali::DaliException e) {
97832       {
97833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97834       };
97835     } catch (...) {
97836       {
97837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97838       };
97839     }
97840   }
97841
97842 }
97843
97844
97845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97846   unsigned int jresult ;
97847   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97848   Dali::Toolkit::Control arg2 ;
97849   Dali::KeyEvent *arg3 = 0 ;
97850   Dali::Toolkit::Control *argp2 ;
97851   bool result;
97852
97853   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97854   argp2 = (Dali::Toolkit::Control *)jarg2;
97855   if (!argp2) {
97856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97857     return 0;
97858   }
97859   arg2 = *argp2;
97860   arg3 = (Dali::KeyEvent *)jarg3;
97861   if (!arg3) {
97862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97863     return 0;
97864   }
97865   {
97866     try {
97867       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);
97868     } catch (std::out_of_range& e) {
97869       {
97870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97871       };
97872     } catch (std::exception& e) {
97873       {
97874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97875       };
97876     } catch (Dali::DaliException e) {
97877       {
97878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97879       };
97880     } catch (...) {
97881       {
97882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97883       };
97884     }
97885   }
97886
97887   jresult = result;
97888   return jresult;
97889 }
97890
97891
97892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97893   void * jresult ;
97894   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97895
97896   {
97897     try {
97898       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97899     } catch (std::out_of_range& e) {
97900       {
97901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97902       };
97903     } catch (std::exception& e) {
97904       {
97905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97906       };
97907     } catch (Dali::DaliException e) {
97908       {
97909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97910       };
97911     } catch (...) {
97912       {
97913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97914       };
97915     }
97916   }
97917
97918   jresult = (void *)result;
97919   return jresult;
97920 }
97921
97922
97923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97924   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97925
97926   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97927   {
97928     try {
97929       delete arg1;
97930     } catch (std::out_of_range& e) {
97931       {
97932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97933       };
97934     } catch (std::exception& e) {
97935       {
97936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97937       };
97938     } catch (Dali::DaliException e) {
97939       {
97940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97941       };
97942     } catch (...) {
97943       {
97944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97945       };
97946     }
97947   }
97948
97949 }
97950
97951
97952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97953   unsigned int jresult ;
97954   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97955   bool result;
97956
97957   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97958   {
97959     try {
97960       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97961     } catch (std::out_of_range& e) {
97962       {
97963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97964       };
97965     } catch (std::exception& e) {
97966       {
97967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97968       };
97969     } catch (Dali::DaliException e) {
97970       {
97971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97972       };
97973     } catch (...) {
97974       {
97975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97976       };
97977     }
97978   }
97979
97980   jresult = result;
97981   return jresult;
97982 }
97983
97984
97985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97986   unsigned long jresult ;
97987   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97988   std::size_t result;
97989
97990   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97991   {
97992     try {
97993       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97994     } catch (std::out_of_range& e) {
97995       {
97996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97997       };
97998     } catch (std::exception& e) {
97999       {
98000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98001       };
98002     } catch (Dali::DaliException e) {
98003       {
98004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98005       };
98006     } catch (...) {
98007       {
98008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98009       };
98010     }
98011   }
98012
98013   jresult = (unsigned long)result;
98014   return jresult;
98015 }
98016
98017
98018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98019   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98020   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98021
98022   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98023   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98024   {
98025     try {
98026       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98027     } catch (std::out_of_range& e) {
98028       {
98029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98030       };
98031     } catch (std::exception& e) {
98032       {
98033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98034       };
98035     } catch (Dali::DaliException e) {
98036       {
98037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98038       };
98039     } catch (...) {
98040       {
98041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98042       };
98043     }
98044   }
98045
98046 }
98047
98048
98049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98050   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98051   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98052
98053   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98054   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98055   {
98056     try {
98057       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98058     } catch (std::out_of_range& e) {
98059       {
98060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98061       };
98062     } catch (std::exception& e) {
98063       {
98064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98065       };
98066     } catch (Dali::DaliException e) {
98067       {
98068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98069       };
98070     } catch (...) {
98071       {
98072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98073       };
98074     }
98075   }
98076
98077 }
98078
98079
98080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98081   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98082   Dali::Toolkit::Control arg2 ;
98083   Dali::Toolkit::Control *argp2 ;
98084
98085   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98086   argp2 = (Dali::Toolkit::Control *)jarg2;
98087   if (!argp2) {
98088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98089     return ;
98090   }
98091   arg2 = *argp2;
98092   {
98093     try {
98094       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98095     } catch (std::out_of_range& e) {
98096       {
98097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98098       };
98099     } catch (std::exception& e) {
98100       {
98101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98102       };
98103     } catch (Dali::DaliException e) {
98104       {
98105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98106       };
98107     } catch (...) {
98108       {
98109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98110       };
98111     }
98112   }
98113
98114 }
98115
98116
98117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98118   void * jresult ;
98119   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98120
98121   {
98122     try {
98123       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98124     } catch (std::out_of_range& e) {
98125       {
98126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98127       };
98128     } catch (std::exception& e) {
98129       {
98130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98131       };
98132     } catch (Dali::DaliException e) {
98133       {
98134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98135       };
98136     } catch (...) {
98137       {
98138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98139       };
98140     }
98141   }
98142
98143   jresult = (void *)result;
98144   return jresult;
98145 }
98146
98147
98148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98149   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98150
98151   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98152   {
98153     try {
98154       delete arg1;
98155     } catch (std::out_of_range& e) {
98156       {
98157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98158       };
98159     } catch (std::exception& e) {
98160       {
98161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98162       };
98163     } catch (Dali::DaliException e) {
98164       {
98165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98166       };
98167     } catch (...) {
98168       {
98169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98170       };
98171     }
98172   }
98173
98174 }
98175
98176
98177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98178   unsigned int jresult ;
98179   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98180   bool result;
98181
98182   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98183   {
98184     try {
98185       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98186     } catch (std::out_of_range& e) {
98187       {
98188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98189       };
98190     } catch (std::exception& e) {
98191       {
98192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98193       };
98194     } catch (Dali::DaliException e) {
98195       {
98196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98197       };
98198     } catch (...) {
98199       {
98200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98201       };
98202     }
98203   }
98204
98205   jresult = result;
98206   return jresult;
98207 }
98208
98209
98210 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98211   unsigned long jresult ;
98212   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98213   std::size_t result;
98214
98215   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98216   {
98217     try {
98218       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98219     } catch (std::out_of_range& e) {
98220       {
98221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98222       };
98223     } catch (std::exception& e) {
98224       {
98225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98226       };
98227     } catch (Dali::DaliException e) {
98228       {
98229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98230       };
98231     } catch (...) {
98232       {
98233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98234       };
98235     }
98236   }
98237
98238   jresult = (unsigned long)result;
98239   return jresult;
98240 }
98241
98242
98243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98244   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98245   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98246
98247   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98248   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98249   {
98250     try {
98251       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98252     } catch (std::out_of_range& e) {
98253       {
98254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98255       };
98256     } catch (std::exception& e) {
98257       {
98258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98259       };
98260     } catch (Dali::DaliException e) {
98261       {
98262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98263       };
98264     } catch (...) {
98265       {
98266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98267       };
98268     }
98269   }
98270
98271 }
98272
98273
98274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98275   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98276   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98277
98278   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98279   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98280   {
98281     try {
98282       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98283     } catch (std::out_of_range& e) {
98284       {
98285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98286       };
98287     } catch (std::exception& e) {
98288       {
98289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98290       };
98291     } catch (Dali::DaliException e) {
98292       {
98293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98294       };
98295     } catch (...) {
98296       {
98297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98298       };
98299     }
98300   }
98301
98302 }
98303
98304
98305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98306   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98307   Dali::Toolkit::VideoView *arg2 = 0 ;
98308
98309   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98310   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98311   if (!arg2) {
98312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98313     return ;
98314   }
98315   {
98316     try {
98317       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98318     } catch (std::out_of_range& e) {
98319       {
98320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98321       };
98322     } catch (std::exception& e) {
98323       {
98324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98325       };
98326     } catch (Dali::DaliException e) {
98327       {
98328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98329       };
98330     } catch (...) {
98331       {
98332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98333       };
98334     }
98335   }
98336
98337 }
98338
98339
98340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98341   void * jresult ;
98342   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98343
98344   {
98345     try {
98346       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98347     } catch (std::out_of_range& e) {
98348       {
98349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98350       };
98351     } catch (std::exception& e) {
98352       {
98353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98354       };
98355     } catch (Dali::DaliException e) {
98356       {
98357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98358       };
98359     } catch (...) {
98360       {
98361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98362       };
98363     }
98364   }
98365
98366   jresult = (void *)result;
98367   return jresult;
98368 }
98369
98370
98371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98372   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98373
98374   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98375   {
98376     try {
98377       delete arg1;
98378     } catch (std::out_of_range& e) {
98379       {
98380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98381       };
98382     } catch (std::exception& e) {
98383       {
98384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98385       };
98386     } catch (Dali::DaliException e) {
98387       {
98388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98389       };
98390     } catch (...) {
98391       {
98392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98393       };
98394     }
98395   }
98396
98397 }
98398
98399
98400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98401   unsigned int jresult ;
98402   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98403   bool result;
98404
98405   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98406   {
98407     try {
98408       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98409     } catch (std::out_of_range& e) {
98410       {
98411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98412       };
98413     } catch (std::exception& e) {
98414       {
98415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98416       };
98417     } catch (Dali::DaliException e) {
98418       {
98419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98420       };
98421     } catch (...) {
98422       {
98423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98424       };
98425     }
98426   }
98427
98428   jresult = result;
98429   return jresult;
98430 }
98431
98432
98433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98434   unsigned long jresult ;
98435   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98436   std::size_t result;
98437
98438   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98439   {
98440     try {
98441       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98442     } catch (std::out_of_range& e) {
98443       {
98444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98445       };
98446     } catch (std::exception& e) {
98447       {
98448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98449       };
98450     } catch (Dali::DaliException e) {
98451       {
98452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98453       };
98454     } catch (...) {
98455       {
98456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98457       };
98458     }
98459   }
98460
98461   jresult = (unsigned long)result;
98462   return jresult;
98463 }
98464
98465
98466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98467   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98468   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98469
98470   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98471   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98472   {
98473     try {
98474       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98475     } catch (std::out_of_range& e) {
98476       {
98477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98478       };
98479     } catch (std::exception& e) {
98480       {
98481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98482       };
98483     } catch (Dali::DaliException e) {
98484       {
98485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98486       };
98487     } catch (...) {
98488       {
98489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98490       };
98491     }
98492   }
98493
98494 }
98495
98496
98497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98498   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98499   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98500
98501   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98502   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98503   {
98504     try {
98505       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98506     } catch (std::out_of_range& e) {
98507       {
98508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98509       };
98510     } catch (std::exception& e) {
98511       {
98512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98513       };
98514     } catch (Dali::DaliException e) {
98515       {
98516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98517       };
98518     } catch (...) {
98519       {
98520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98521       };
98522     }
98523   }
98524
98525 }
98526
98527
98528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98529   unsigned int jresult ;
98530   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98531   Dali::Toolkit::Slider arg2 ;
98532   float arg3 ;
98533   Dali::Toolkit::Slider *argp2 ;
98534   bool result;
98535
98536   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98537   argp2 = (Dali::Toolkit::Slider *)jarg2;
98538   if (!argp2) {
98539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98540     return 0;
98541   }
98542   arg2 = *argp2;
98543   arg3 = (float)jarg3;
98544   {
98545     try {
98546       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98547     } catch (std::out_of_range& e) {
98548       {
98549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98550       };
98551     } catch (std::exception& e) {
98552       {
98553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98554       };
98555     } catch (Dali::DaliException e) {
98556       {
98557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98558       };
98559     } catch (...) {
98560       {
98561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98562       };
98563     }
98564   }
98565
98566   jresult = result;
98567   return jresult;
98568 }
98569
98570
98571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98572   void * jresult ;
98573   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98574
98575   {
98576     try {
98577       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98578     } catch (std::out_of_range& e) {
98579       {
98580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98581       };
98582     } catch (std::exception& e) {
98583       {
98584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98585       };
98586     } catch (Dali::DaliException e) {
98587       {
98588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98589       };
98590     } catch (...) {
98591       {
98592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98593       };
98594     }
98595   }
98596
98597   jresult = (void *)result;
98598   return jresult;
98599 }
98600
98601
98602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98603   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98604
98605   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98606   {
98607     try {
98608       delete arg1;
98609     } catch (std::out_of_range& e) {
98610       {
98611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98612       };
98613     } catch (std::exception& e) {
98614       {
98615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98616       };
98617     } catch (Dali::DaliException e) {
98618       {
98619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98620       };
98621     } catch (...) {
98622       {
98623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98624       };
98625     }
98626   }
98627
98628 }
98629
98630
98631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98632   unsigned int jresult ;
98633   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98634   bool result;
98635
98636   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98637   {
98638     try {
98639       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98640     } catch (std::out_of_range& e) {
98641       {
98642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98643       };
98644     } catch (std::exception& e) {
98645       {
98646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98647       };
98648     } catch (Dali::DaliException e) {
98649       {
98650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98651       };
98652     } catch (...) {
98653       {
98654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98655       };
98656     }
98657   }
98658
98659   jresult = result;
98660   return jresult;
98661 }
98662
98663
98664 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98665   unsigned long jresult ;
98666   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98667   std::size_t result;
98668
98669   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98670   {
98671     try {
98672       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98673     } catch (std::out_of_range& e) {
98674       {
98675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98676       };
98677     } catch (std::exception& e) {
98678       {
98679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98680       };
98681     } catch (Dali::DaliException e) {
98682       {
98683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98684       };
98685     } catch (...) {
98686       {
98687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98688       };
98689     }
98690   }
98691
98692   jresult = (unsigned long)result;
98693   return jresult;
98694 }
98695
98696
98697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98698   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98699   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98700
98701   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98702   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98703   {
98704     try {
98705       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98706     } catch (std::out_of_range& e) {
98707       {
98708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98709       };
98710     } catch (std::exception& e) {
98711       {
98712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98713       };
98714     } catch (Dali::DaliException e) {
98715       {
98716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98717       };
98718     } catch (...) {
98719       {
98720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98721       };
98722     }
98723   }
98724
98725 }
98726
98727
98728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98729   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98730   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98731
98732   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98733   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98734   {
98735     try {
98736       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98737     } catch (std::out_of_range& e) {
98738       {
98739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98740       };
98741     } catch (std::exception& e) {
98742       {
98743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98744       };
98745     } catch (Dali::DaliException e) {
98746       {
98747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98748       };
98749     } catch (...) {
98750       {
98751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98752       };
98753     }
98754   }
98755
98756 }
98757
98758
98759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98760   unsigned int jresult ;
98761   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98762   Dali::Toolkit::Slider arg2 ;
98763   int arg3 ;
98764   Dali::Toolkit::Slider *argp2 ;
98765   bool result;
98766
98767   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98768   argp2 = (Dali::Toolkit::Slider *)jarg2;
98769   if (!argp2) {
98770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98771     return 0;
98772   }
98773   arg2 = *argp2;
98774   arg3 = (int)jarg3;
98775   {
98776     try {
98777       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98778     } catch (std::out_of_range& e) {
98779       {
98780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98781       };
98782     } catch (std::exception& e) {
98783       {
98784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98785       };
98786     } catch (Dali::DaliException e) {
98787       {
98788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98789       };
98790     } catch (...) {
98791       {
98792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98793       };
98794     }
98795   }
98796
98797   jresult = result;
98798   return jresult;
98799 }
98800
98801
98802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98803   void * jresult ;
98804   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98805
98806   {
98807     try {
98808       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98809     } catch (std::out_of_range& e) {
98810       {
98811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98812       };
98813     } catch (std::exception& e) {
98814       {
98815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98816       };
98817     } catch (Dali::DaliException e) {
98818       {
98819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98820       };
98821     } catch (...) {
98822       {
98823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98824       };
98825     }
98826   }
98827
98828   jresult = (void *)result;
98829   return jresult;
98830 }
98831
98832
98833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98834   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98835
98836   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98837   {
98838     try {
98839       delete arg1;
98840     } catch (std::out_of_range& e) {
98841       {
98842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98843       };
98844     } catch (std::exception& e) {
98845       {
98846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98847       };
98848     } catch (Dali::DaliException e) {
98849       {
98850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98851       };
98852     } catch (...) {
98853       {
98854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98855       };
98856     }
98857   }
98858
98859 }
98860
98861
98862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98863   void * jresult ;
98864   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98865
98866   {
98867     try {
98868       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98869     } catch (std::out_of_range& e) {
98870       {
98871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98872       };
98873     } catch (std::exception& e) {
98874       {
98875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98876       };
98877     } catch (Dali::DaliException e) {
98878       {
98879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98880       };
98881     } catch (...) {
98882       {
98883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98884       };
98885     }
98886   }
98887
98888   jresult = (void *)result;
98889   return jresult;
98890 }
98891
98892
98893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98894   void * jresult ;
98895   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98896   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98897
98898   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98899   {
98900     try {
98901       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98902     } catch (std::out_of_range& e) {
98903       {
98904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98905       };
98906     } catch (std::exception& e) {
98907       {
98908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98909       };
98910     } catch (Dali::DaliException e) {
98911       {
98912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98913       };
98914     } catch (...) {
98915       {
98916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98917       };
98918     }
98919   }
98920
98921   jresult = (void *)result;
98922   return jresult;
98923 }
98924
98925
98926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98927   void * jresult ;
98928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98929   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98930
98931   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98932   if (!arg1) {
98933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98934     return 0;
98935   }
98936   {
98937     try {
98938       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98939     } catch (std::out_of_range& e) {
98940       {
98941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98942       };
98943     } catch (std::exception& e) {
98944       {
98945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98946       };
98947     } catch (Dali::DaliException e) {
98948       {
98949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98950       };
98951     } catch (...) {
98952       {
98953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98954       };
98955     }
98956   }
98957
98958   jresult = (void *)result;
98959   return jresult;
98960 }
98961
98962
98963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98964   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98965
98966   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98967   {
98968     try {
98969       delete arg1;
98970     } catch (std::out_of_range& e) {
98971       {
98972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98973       };
98974     } catch (std::exception& e) {
98975       {
98976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98977       };
98978     } catch (Dali::DaliException e) {
98979       {
98980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98981       };
98982     } catch (...) {
98983       {
98984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98985       };
98986     }
98987   }
98988
98989 }
98990
98991
98992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98993   void * jresult ;
98994   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98995   Dali::Toolkit::Ruler *result = 0 ;
98996
98997   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98998   {
98999     try {
99000       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99001     } catch (std::out_of_range& e) {
99002       {
99003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99004       };
99005     } catch (std::exception& e) {
99006       {
99007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99008       };
99009     } catch (Dali::DaliException e) {
99010       {
99011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99012       };
99013     } catch (...) {
99014       {
99015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99016       };
99017     }
99018   }
99019
99020   jresult = (void *)result;
99021   return jresult;
99022 }
99023
99024
99025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99026   void * jresult ;
99027   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99028   Dali::Toolkit::Ruler *result = 0 ;
99029
99030   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99031   {
99032     try {
99033       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99034     } catch (std::out_of_range& e) {
99035       {
99036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99037       };
99038     } catch (std::exception& e) {
99039       {
99040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99041       };
99042     } catch (Dali::DaliException e) {
99043       {
99044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99045       };
99046     } catch (...) {
99047       {
99048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99049       };
99050     }
99051   }
99052
99053   jresult = (void *)result;
99054   return jresult;
99055 }
99056
99057
99058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99059   void * jresult ;
99060   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99061   Dali::Toolkit::Ruler *result = 0 ;
99062
99063   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99064   {
99065     try {
99066       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99067     } catch (std::out_of_range& e) {
99068       {
99069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99070       };
99071     } catch (std::exception& e) {
99072       {
99073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99074       };
99075     } catch (Dali::DaliException e) {
99076       {
99077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99078       };
99079     } catch (...) {
99080       {
99081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99082       };
99083     }
99084   }
99085
99086   jresult = (void *)result;
99087   return jresult;
99088 }
99089
99090
99091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99092   void * jresult ;
99093   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99094   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99095   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99096
99097   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99098   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99099   if (!arg2) {
99100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99101     return 0;
99102   }
99103   {
99104     try {
99105       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99106     } catch (std::out_of_range& e) {
99107       {
99108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99109       };
99110     } catch (std::exception& e) {
99111       {
99112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99113       };
99114     } catch (Dali::DaliException e) {
99115       {
99116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99117       };
99118     } catch (...) {
99119       {
99120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99121       };
99122     }
99123   }
99124
99125   jresult = (void *)result;
99126   return jresult;
99127 }
99128
99129
99130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99131   void * jresult ;
99132   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99133   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99134   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99135
99136   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99137   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99138   {
99139     try {
99140       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99141     } catch (std::out_of_range& e) {
99142       {
99143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99144       };
99145     } catch (std::exception& e) {
99146       {
99147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99148       };
99149     } catch (Dali::DaliException e) {
99150       {
99151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99152       };
99153     } catch (...) {
99154       {
99155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99156       };
99157     }
99158   }
99159
99160   jresult = (void *)result;
99161   return jresult;
99162 }
99163
99164
99165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99166   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99167
99168   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99169   {
99170     try {
99171       (arg1)->Reset();
99172     } catch (std::out_of_range& e) {
99173       {
99174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99175       };
99176     } catch (std::exception& e) {
99177       {
99178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99179       };
99180     } catch (Dali::DaliException e) {
99181       {
99182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99183       };
99184     } catch (...) {
99185       {
99186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99187       };
99188     }
99189   }
99190
99191 }
99192
99193
99194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99195   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99196   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99197
99198   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99199   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99200   {
99201     try {
99202       (arg1)->Reset(arg2);
99203     } catch (std::out_of_range& e) {
99204       {
99205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99206       };
99207     } catch (std::exception& e) {
99208       {
99209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99210       };
99211     } catch (Dali::DaliException e) {
99212       {
99213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99214       };
99215     } catch (...) {
99216       {
99217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99218       };
99219     }
99220   }
99221
99222 }
99223
99224
99225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99226   void * jresult ;
99227   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99228   Dali::Toolkit::Ruler *result = 0 ;
99229
99230   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99231   {
99232     try {
99233       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99234     } catch (std::out_of_range& e) {
99235       {
99236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99237       };
99238     } catch (std::exception& e) {
99239       {
99240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99241       };
99242     } catch (Dali::DaliException e) {
99243       {
99244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99245       };
99246     } catch (...) {
99247       {
99248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99249       };
99250     }
99251   }
99252
99253   jresult = (void *)result;
99254   return jresult;
99255 }
99256
99257
99258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99259   float jresult ;
99260   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99261   float arg2 ;
99262   float arg3 ;
99263   float result;
99264
99265   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99266   arg2 = (float)jarg2;
99267   arg3 = (float)jarg3;
99268   {
99269     try {
99270       result = (float)(*arg1)->Snap(arg2,arg3);
99271     } catch (std::out_of_range& e) {
99272       {
99273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99274       };
99275     } catch (std::exception& e) {
99276       {
99277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99278       };
99279     } catch (Dali::DaliException e) {
99280       {
99281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99282       };
99283     } catch (...) {
99284       {
99285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99286       };
99287     }
99288   }
99289
99290   jresult = result;
99291   return jresult;
99292 }
99293
99294
99295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99296   float jresult ;
99297   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99298   float arg2 ;
99299   float result;
99300
99301   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99302   arg2 = (float)jarg2;
99303   {
99304     try {
99305       result = (float)(*arg1)->Snap(arg2);
99306     } catch (std::out_of_range& e) {
99307       {
99308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99309       };
99310     } catch (std::exception& e) {
99311       {
99312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99313       };
99314     } catch (Dali::DaliException e) {
99315       {
99316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99317       };
99318     } catch (...) {
99319       {
99320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99321       };
99322     }
99323   }
99324
99325   jresult = result;
99326   return jresult;
99327 }
99328
99329
99330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99331   float jresult ;
99332   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99333   unsigned int arg2 ;
99334   unsigned int *arg3 = 0 ;
99335   bool arg4 ;
99336   float result;
99337
99338   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99339   arg2 = (unsigned int)jarg2;
99340   arg3 = (unsigned int *)jarg3;
99341   arg4 = jarg4 ? true : false;
99342   {
99343     try {
99344       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99345     } catch (std::out_of_range& e) {
99346       {
99347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99348       };
99349     } catch (std::exception& e) {
99350       {
99351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99352       };
99353     } catch (Dali::DaliException e) {
99354       {
99355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99356       };
99357     } catch (...) {
99358       {
99359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99360       };
99361     }
99362   }
99363
99364   jresult = result;
99365   return jresult;
99366 }
99367
99368
99369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99370   unsigned int jresult ;
99371   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99372   float arg2 ;
99373   bool arg3 ;
99374   unsigned int result;
99375
99376   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99377   arg2 = (float)jarg2;
99378   arg3 = jarg3 ? true : false;
99379   {
99380     try {
99381       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99382     } catch (std::out_of_range& e) {
99383       {
99384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99385       };
99386     } catch (std::exception& e) {
99387       {
99388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99389       };
99390     } catch (Dali::DaliException e) {
99391       {
99392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99393       };
99394     } catch (...) {
99395       {
99396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99397       };
99398     }
99399   }
99400
99401   jresult = result;
99402   return jresult;
99403 }
99404
99405
99406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99407   unsigned int jresult ;
99408   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99409   unsigned int result;
99410
99411   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99412   {
99413     try {
99414       result = (unsigned int)(*arg1)->GetTotalPages();
99415     } catch (std::out_of_range& e) {
99416       {
99417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99418       };
99419     } catch (std::exception& e) {
99420       {
99421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99422       };
99423     } catch (Dali::DaliException e) {
99424       {
99425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99426       };
99427     } catch (...) {
99428       {
99429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99430       };
99431     }
99432   }
99433
99434   jresult = result;
99435   return jresult;
99436 }
99437
99438
99439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99440   int jresult ;
99441   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99442   Dali::Toolkit::Ruler::RulerType result;
99443
99444   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99445   {
99446     try {
99447       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99448     } catch (std::out_of_range& e) {
99449       {
99450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99451       };
99452     } catch (std::exception& e) {
99453       {
99454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99455       };
99456     } catch (Dali::DaliException e) {
99457       {
99458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99459       };
99460     } catch (...) {
99461       {
99462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99463       };
99464     }
99465   }
99466
99467   jresult = (int)result;
99468   return jresult;
99469 }
99470
99471
99472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99473   unsigned int jresult ;
99474   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99475   bool result;
99476
99477   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99478   {
99479     try {
99480       result = (bool)(*arg1)->IsEnabled();
99481     } catch (std::out_of_range& e) {
99482       {
99483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99484       };
99485     } catch (std::exception& e) {
99486       {
99487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99488       };
99489     } catch (Dali::DaliException e) {
99490       {
99491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99492       };
99493     } catch (...) {
99494       {
99495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99496       };
99497     }
99498   }
99499
99500   jresult = result;
99501   return jresult;
99502 }
99503
99504
99505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99506   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99507
99508   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99509   {
99510     try {
99511       (*arg1)->Enable();
99512     } catch (std::out_of_range& e) {
99513       {
99514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99515       };
99516     } catch (std::exception& e) {
99517       {
99518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99519       };
99520     } catch (Dali::DaliException e) {
99521       {
99522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99523       };
99524     } catch (...) {
99525       {
99526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99527       };
99528     }
99529   }
99530
99531 }
99532
99533
99534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99535   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99536
99537   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99538   {
99539     try {
99540       (*arg1)->Disable();
99541     } catch (std::out_of_range& e) {
99542       {
99543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99544       };
99545     } catch (std::exception& e) {
99546       {
99547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99548       };
99549     } catch (Dali::DaliException e) {
99550       {
99551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99552       };
99553     } catch (...) {
99554       {
99555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99556       };
99557     }
99558   }
99559
99560 }
99561
99562
99563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99564   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99565   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99566   Dali::Toolkit::RulerDomain *argp2 ;
99567
99568   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99569   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99570   if (!argp2) {
99571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99572     return ;
99573   }
99574   arg2 = *argp2;
99575   {
99576     try {
99577       (*arg1)->SetDomain(arg2);
99578     } catch (std::out_of_range& e) {
99579       {
99580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99581       };
99582     } catch (std::exception& e) {
99583       {
99584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99585       };
99586     } catch (Dali::DaliException e) {
99587       {
99588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99589       };
99590     } catch (...) {
99591       {
99592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99593       };
99594     }
99595   }
99596
99597 }
99598
99599
99600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99601   void * jresult ;
99602   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99603   Dali::Toolkit::RulerDomain *result = 0 ;
99604
99605   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99606   {
99607     try {
99608       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99609     } catch (std::out_of_range& e) {
99610       {
99611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99612       };
99613     } catch (std::exception& e) {
99614       {
99615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99616       };
99617     } catch (Dali::DaliException e) {
99618       {
99619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99620       };
99621     } catch (...) {
99622       {
99623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99624       };
99625     }
99626   }
99627
99628   jresult = (void *)result;
99629   return jresult;
99630 }
99631
99632
99633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99634   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99635
99636   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99637   {
99638     try {
99639       (*arg1)->DisableDomain();
99640     } catch (std::out_of_range& e) {
99641       {
99642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99643       };
99644     } catch (std::exception& e) {
99645       {
99646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99647       };
99648     } catch (Dali::DaliException e) {
99649       {
99650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99651       };
99652     } catch (...) {
99653       {
99654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99655       };
99656     }
99657   }
99658
99659 }
99660
99661
99662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99663   float jresult ;
99664   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99665   float arg2 ;
99666   float arg3 ;
99667   float arg4 ;
99668   float result;
99669
99670   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99671   arg2 = (float)jarg2;
99672   arg3 = (float)jarg3;
99673   arg4 = (float)jarg4;
99674   {
99675     try {
99676       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99677     } catch (std::out_of_range& e) {
99678       {
99679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99680       };
99681     } catch (std::exception& e) {
99682       {
99683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99684       };
99685     } catch (Dali::DaliException e) {
99686       {
99687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99688       };
99689     } catch (...) {
99690       {
99691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99692       };
99693     }
99694   }
99695
99696   jresult = result;
99697   return jresult;
99698 }
99699
99700
99701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99702   float jresult ;
99703   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99704   float arg2 ;
99705   float arg3 ;
99706   float result;
99707
99708   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99709   arg2 = (float)jarg2;
99710   arg3 = (float)jarg3;
99711   {
99712     try {
99713       result = (float)(*arg1)->Clamp(arg2,arg3);
99714     } catch (std::out_of_range& e) {
99715       {
99716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99717       };
99718     } catch (std::exception& e) {
99719       {
99720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99721       };
99722     } catch (Dali::DaliException e) {
99723       {
99724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99725       };
99726     } catch (...) {
99727       {
99728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99729       };
99730     }
99731   }
99732
99733   jresult = result;
99734   return jresult;
99735 }
99736
99737
99738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99739   float jresult ;
99740   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99741   float arg2 ;
99742   float result;
99743
99744   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99745   arg2 = (float)jarg2;
99746   {
99747     try {
99748       result = (float)(*arg1)->Clamp(arg2);
99749     } catch (std::out_of_range& e) {
99750       {
99751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99752       };
99753     } catch (std::exception& e) {
99754       {
99755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99756       };
99757     } catch (Dali::DaliException e) {
99758       {
99759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99760       };
99761     } catch (...) {
99762       {
99763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99764       };
99765     }
99766   }
99767
99768   jresult = result;
99769   return jresult;
99770 }
99771
99772
99773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99774   float jresult ;
99775   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99776   float arg2 ;
99777   float arg3 ;
99778   float arg4 ;
99779   Dali::Toolkit::ClampState *arg5 = 0 ;
99780   float result;
99781
99782   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99783   arg2 = (float)jarg2;
99784   arg3 = (float)jarg3;
99785   arg4 = (float)jarg4;
99786   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99787   if (!arg5) {
99788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99789     return 0;
99790   }
99791   {
99792     try {
99793       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99794     } catch (std::out_of_range& e) {
99795       {
99796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99797       };
99798     } catch (std::exception& e) {
99799       {
99800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99801       };
99802     } catch (Dali::DaliException e) {
99803       {
99804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99805       };
99806     } catch (...) {
99807       {
99808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99809       };
99810     }
99811   }
99812
99813   jresult = result;
99814   return jresult;
99815 }
99816
99817
99818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99819   float jresult ;
99820   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99821   float arg2 ;
99822   float arg3 ;
99823   float arg4 ;
99824   float arg5 ;
99825   float result;
99826
99827   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99828   arg2 = (float)jarg2;
99829   arg3 = (float)jarg3;
99830   arg4 = (float)jarg4;
99831   arg5 = (float)jarg5;
99832   {
99833     try {
99834       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99835     } catch (std::out_of_range& e) {
99836       {
99837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99838       };
99839     } catch (std::exception& e) {
99840       {
99841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99842       };
99843     } catch (Dali::DaliException e) {
99844       {
99845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99846       };
99847     } catch (...) {
99848       {
99849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99850       };
99851     }
99852   }
99853
99854   jresult = result;
99855   return jresult;
99856 }
99857
99858
99859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99860   float jresult ;
99861   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99862   float arg2 ;
99863   float arg3 ;
99864   float arg4 ;
99865   float result;
99866
99867   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99868   arg2 = (float)jarg2;
99869   arg3 = (float)jarg3;
99870   arg4 = (float)jarg4;
99871   {
99872     try {
99873       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99874     } catch (std::out_of_range& e) {
99875       {
99876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99877       };
99878     } catch (std::exception& e) {
99879       {
99880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99881       };
99882     } catch (Dali::DaliException e) {
99883       {
99884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99885       };
99886     } catch (...) {
99887       {
99888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99889       };
99890     }
99891   }
99892
99893   jresult = result;
99894   return jresult;
99895 }
99896
99897
99898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99899   float jresult ;
99900   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99901   float arg2 ;
99902   float arg3 ;
99903   float result;
99904
99905   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99906   arg2 = (float)jarg2;
99907   arg3 = (float)jarg3;
99908   {
99909     try {
99910       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99911     } catch (std::out_of_range& e) {
99912       {
99913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99914       };
99915     } catch (std::exception& e) {
99916       {
99917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99918       };
99919     } catch (Dali::DaliException e) {
99920       {
99921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99922       };
99923     } catch (...) {
99924       {
99925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99926       };
99927     }
99928   }
99929
99930   jresult = result;
99931   return jresult;
99932 }
99933
99934
99935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99936   float jresult ;
99937   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99938   float arg2 ;
99939   float result;
99940
99941   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99942   arg2 = (float)jarg2;
99943   {
99944     try {
99945       result = (float)(*arg1)->SnapAndClamp(arg2);
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 float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99971   float jresult ;
99972   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99973   float arg2 ;
99974   float arg3 ;
99975   float arg4 ;
99976   float arg5 ;
99977   Dali::Toolkit::ClampState *arg6 = 0 ;
99978   float result;
99979
99980   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99981   arg2 = (float)jarg2;
99982   arg3 = (float)jarg3;
99983   arg4 = (float)jarg4;
99984   arg5 = (float)jarg5;
99985   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99986   if (!arg6) {
99987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99988     return 0;
99989   }
99990   {
99991     try {
99992       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99993     } catch (std::out_of_range& e) {
99994       {
99995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99996       };
99997     } catch (std::exception& e) {
99998       {
99999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100000       };
100001     } catch (Dali::DaliException e) {
100002       {
100003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100004       };
100005     } catch (...) {
100006       {
100007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100008       };
100009     }
100010   }
100011
100012   jresult = result;
100013   return jresult;
100014 }
100015
100016
100017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100018   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100019
100020   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100021   {
100022     try {
100023       (*arg1)->Reference();
100024     } catch (std::out_of_range& e) {
100025       {
100026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100027       };
100028     } catch (std::exception& e) {
100029       {
100030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100031       };
100032     } catch (Dali::DaliException e) {
100033       {
100034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100035       };
100036     } catch (...) {
100037       {
100038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100039       };
100040     }
100041   }
100042
100043 }
100044
100045
100046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100047   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100048
100049   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100050   {
100051     try {
100052       (*arg1)->Unreference();
100053     } catch (std::out_of_range& e) {
100054       {
100055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100056       };
100057     } catch (std::exception& e) {
100058       {
100059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100060       };
100061     } catch (Dali::DaliException e) {
100062       {
100063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100064       };
100065     } catch (...) {
100066       {
100067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100068       };
100069     }
100070   }
100071
100072 }
100073
100074
100075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100076   int jresult ;
100077   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100078   int result;
100079
100080   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100081   {
100082     try {
100083       result = (int)(*arg1)->ReferenceCount();
100084     } catch (std::out_of_range& e) {
100085       {
100086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100087       };
100088     } catch (std::exception& e) {
100089       {
100090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100091       };
100092     } catch (Dali::DaliException e) {
100093       {
100094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100095       };
100096     } catch (...) {
100097       {
100098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100099       };
100100     }
100101   }
100102
100103   jresult = result;
100104   return jresult;
100105 }
100106
100107
100108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100109   unsigned int jresult ;
100110   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100111   bool result;
100112
100113   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100114   {
100115     try {
100116       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100117     } catch (std::out_of_range& e) {
100118       {
100119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100120       };
100121     } catch (std::exception& e) {
100122       {
100123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100124       };
100125     } catch (Dali::DaliException e) {
100126       {
100127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100128       };
100129     } catch (...) {
100130       {
100131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100132       };
100133     }
100134   }
100135
100136   jresult = result;
100137   return jresult;
100138 }
100139
100140
100141 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100142   unsigned long jresult ;
100143   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100144   std::size_t result;
100145
100146   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100147   {
100148     try {
100149       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100150     } catch (std::out_of_range& e) {
100151       {
100152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100153       };
100154     } catch (std::exception& e) {
100155       {
100156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100157       };
100158     } catch (Dali::DaliException e) {
100159       {
100160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100161       };
100162     } catch (...) {
100163       {
100164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100165       };
100166     }
100167   }
100168
100169   jresult = (unsigned long)result;
100170   return jresult;
100171 }
100172
100173
100174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100175   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100176   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100177
100178   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100179   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100180   {
100181     try {
100182       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100183     } catch (std::out_of_range& e) {
100184       {
100185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100186       };
100187     } catch (std::exception& e) {
100188       {
100189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100190       };
100191     } catch (Dali::DaliException e) {
100192       {
100193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100194       };
100195     } catch (...) {
100196       {
100197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100198       };
100199     }
100200   }
100201
100202 }
100203
100204
100205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100206   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100207   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100208
100209   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100210   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100211   {
100212     try {
100213       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100214     } catch (std::out_of_range& e) {
100215       {
100216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100217       };
100218     } catch (std::exception& e) {
100219       {
100220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100221       };
100222     } catch (Dali::DaliException e) {
100223       {
100224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100225       };
100226     } catch (...) {
100227       {
100228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100229       };
100230     }
100231   }
100232
100233 }
100234
100235
100236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100237   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100238   Dali::Toolkit::Control arg2 ;
100239   Dali::Toolkit::Control *argp2 ;
100240
100241   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100242   argp2 = (Dali::Toolkit::Control *)jarg2;
100243   if (!argp2) {
100244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100245     return ;
100246   }
100247   arg2 = *argp2;
100248   {
100249     try {
100250       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100251     } catch (std::out_of_range& e) {
100252       {
100253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100254       };
100255     } catch (std::exception& e) {
100256       {
100257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100258       };
100259     } catch (Dali::DaliException e) {
100260       {
100261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100262       };
100263     } catch (...) {
100264       {
100265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100266       };
100267     }
100268   }
100269
100270 }
100271
100272
100273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100274   void * jresult ;
100275   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100276
100277   {
100278     try {
100279       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100280     } catch (std::out_of_range& e) {
100281       {
100282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100283       };
100284     } catch (std::exception& e) {
100285       {
100286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100287       };
100288     } catch (Dali::DaliException e) {
100289       {
100290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100291       };
100292     } catch (...) {
100293       {
100294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100295       };
100296     }
100297   }
100298
100299   jresult = (void *)result;
100300   return jresult;
100301 }
100302
100303
100304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100305   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100306
100307   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100308   {
100309     try {
100310       delete arg1;
100311     } catch (std::out_of_range& e) {
100312       {
100313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100314       };
100315     } catch (std::exception& e) {
100316       {
100317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100318       };
100319     } catch (Dali::DaliException e) {
100320       {
100321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100322       };
100323     } catch (...) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100326       };
100327     }
100328   }
100329
100330 }
100331
100332 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100333   Dali::RefObject *result = NULL;
100334
100335   if (arg1)
100336   {
100337     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100338   }
100339   return result;
100340 }
100341
100342 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100343     return (Dali::RefObject *)jarg1;
100344 }
100345
100346 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100347     return (Dali::SignalObserver *)jarg1;
100348 }
100349
100350 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100351     return (Dali::ConnectionTrackerInterface *)jarg1;
100352 }
100353
100354 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100355     return (Dali::BaseHandle *)jarg1;
100356 }
100357
100358 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100359     return (Dali::BaseHandle *)jarg1;
100360 }
100361
100362 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100363     return (Dali::BaseHandle *)jarg1;
100364 }
100365
100366 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100367     return (Dali::BaseHandle *)jarg1;
100368 }
100369
100370 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100371     return (Dali::BaseHandle *)jarg1;
100372 }
100373
100374 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100375     return (Dali::BaseHandle *)jarg1;
100376 }
100377
100378 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100379     return (Dali::BaseHandle *)jarg1;
100380 }
100381
100382 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100383     return (Dali::BaseHandle *)jarg1;
100384 }
100385
100386 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100387     return (Dali::BaseHandle *)jarg1;
100388 }
100389
100390 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100391     return (Dali::BaseHandle *)jarg1;
100392 }
100393
100394 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100395     return (Dali::BaseHandle *)jarg1;
100396 }
100397
100398 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100399     return (Dali::BaseHandle *)jarg1;
100400 }
100401
100402 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100403     return (Dali::BaseHandle *)jarg1;
100404 }
100405
100406 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100407     return (Dali::Handle *)jarg1;
100408 }
100409
100410 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100411     return (Dali::Handle *)jarg1;
100412 }
100413
100414 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100415     return (Dali::BaseHandle *)jarg1;
100416 }
100417
100418 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100419     return (Dali::BaseHandle *)jarg1;
100420 }
100421
100422 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100423     return (Dali::Handle *)jarg1;
100424 }
100425
100426 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100427     return (Dali::BaseHandle *)jarg1;
100428 }
100429
100430 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100431     return (Dali::Handle *)jarg1;
100432 }
100433
100434 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100435     return (Dali::GestureDetector *)jarg1;
100436 }
100437
100438 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100439     return (Dali::Gesture *)jarg1;
100440 }
100441
100442 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100443     return (Dali::Handle *)jarg1;
100444 }
100445
100446 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100447     return (Dali::Actor *)jarg1;
100448 }
100449
100450 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100451     return (Dali::BaseHandle *)jarg1;
100452 }
100453
100454 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100455     return (Dali::RefObject *)jarg1;
100456 }
100457
100458 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100459     return (Dali::Actor *)jarg1;
100460 }
100461
100462 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100463     return (Dali::GestureDetector *)jarg1;
100464 }
100465
100466 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100467     return (Dali::Gesture *)jarg1;
100468 }
100469
100470 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100471     return (Dali::GestureDetector *)jarg1;
100472 }
100473
100474 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100475     return (Dali::Gesture *)jarg1;
100476 }
100477
100478 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100479     return (Dali::GestureDetector *)jarg1;
100480 }
100481
100482 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100483     return (Dali::Gesture *)jarg1;
100484 }
100485
100486 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100487     return (Dali::BaseHandle *)jarg1;
100488 }
100489
100490 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100491     return (Dali::Handle *)jarg1;
100492 }
100493
100494 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100495     return (Dali::Handle *)jarg1;
100496 }
100497
100498 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100499     return (Dali::Handle *)jarg1;
100500 }
100501
100502 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100503     return (Dali::Image *)jarg1;
100504 }
100505
100506 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100507     return (Dali::Image *)jarg1;
100508 }
100509
100510 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100511     return (Dali::Image *)jarg1;
100512 }
100513
100514 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100515     return (Dali::RefObject *)jarg1;
100516 }
100517
100518 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100519     return (Dali::Image *)jarg1;
100520 }
100521
100522 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100523     return (Dali::Image *)jarg1;
100524 }
100525
100526 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100527     return (Dali::ResourceImage *)jarg1;
100528 }
100529
100530 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100531     return (Dali::Actor *)jarg1;
100532 }
100533
100534 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100535     return (Dali::BaseHandle *)jarg1;
100536 }
100537
100538 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100539     return (Dali::BaseHandle *)jarg1;
100540 }
100541
100542 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100543     return (Dali::BaseHandle *)jarg1;
100544 }
100545
100546 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100547     return (Dali::CustomActorImpl *)jarg1;
100548 }
100549
100550 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100551     return (Dali::CustomActor *)jarg1;
100552 }
100553
100554 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100555     return (Dali::BaseHandle *)jarg1;
100556 }
100557
100558 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100559     return (Dali::Toolkit::Control *)jarg1;
100560 }
100561
100562 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100563     return (Dali::Toolkit::Control *)jarg1;
100564 }
100565
100566 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100567     return (Dali::Toolkit::Button *)jarg1;
100568 }
100569
100570 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100571     return (Dali::Toolkit::Button *)jarg1;
100572 }
100573
100574 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100575     return (Dali::Toolkit::Button *)jarg1;
100576 }
100577
100578 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100579     return (Dali::Toolkit::Control *)jarg1;
100580 }
100581
100582 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100583     return (Dali::Toolkit::Control *)jarg1;
100584 }
100585
100586 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100587     return (Dali::Toolkit::Control *)jarg1;
100588 }
100589
100590 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100591     return (Dali::Toolkit::Control *)jarg1;
100592 }
100593
100594 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100595     return (Dali::Toolkit::Control *)jarg1;
100596 }
100597
100598 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100599     return (Dali::RefObject *)jarg1;
100600 }
100601
100602 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100603     return (Dali::Toolkit::Scrollable *)jarg1;
100604 }
100605
100606 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100607     return (Dali::BaseHandle *)jarg1;
100608 }
100609
100610 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100611     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100612 }
100613
100614 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100615     return (Dali::RefObject *)jarg1;
100616 }
100617
100618 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100619     return (Dali::Toolkit::Ruler *)jarg1;
100620 }
100621
100622 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100623     return (Dali::Toolkit::Ruler *)jarg1;
100624 }
100625
100626 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100627     return (Dali::Toolkit::Scrollable *)jarg1;
100628 }
100629
100630 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100631     return (Dali::Toolkit::Control *)jarg1;
100632 }
100633
100634
100635 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100636     return (Dali::Toolkit::Control *)jarg1;
100637 }
100638
100639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100640     return (Dali::BaseHandle *)jarg1;
100641 }
100642
100643 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100644     return (Dali::BaseHandle *)jarg1;
100645 }
100646
100647 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100648     return (Dali::Toolkit::Control *)jarg1;
100649 }
100650
100651 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100652     return (Dali::Toolkit::Control *)jarg1;
100653 }
100654
100655 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100656     return (Dali::Toolkit::Control *)jarg1;
100657 }
100658
100659 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100660     return (Dali::Toolkit::Control *)jarg1;
100661 }
100662
100663 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100664     return (Dali::Toolkit::Control *)jarg1;
100665 }
100666
100667 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100668     return (Dali::Toolkit::Control *)jarg1;
100669 }
100670
100671 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100672     return (Dali::Toolkit::PageTurnView *)jarg1;
100673 }
100674
100675 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100676     return (Dali::Toolkit::PageTurnView *)jarg1;
100677 }
100678
100679 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100680     return (Dali::Toolkit::Button *)jarg1;
100681 }
100682
100683 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100684     return (Dali::BaseHandle *)jarg1;
100685 }
100686
100687 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100688     return (Dali::BaseHandle *)jarg1;
100689 }
100690
100691 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100692     return (Dali::BaseHandle *)jarg1;
100693 }
100694
100695 /*
100696  * Widget binding
100697  */
100698 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100699     return (Dali::BaseHandle *)jarg1;
100700 }
100701
100702 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100703     return (Dali::BaseObject *)jarg1;
100704 }
100705
100706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100707   void * jresult ;
100708   Dali::Widget result;
100709
100710   {
100711     try {
100712       result = Dali::Widget::New();
100713     } catch (std::out_of_range& e) {
100714       {
100715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100716       };
100717     } catch (std::exception& e) {
100718       {
100719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100720       };
100721     } catch (...) {
100722       {
100723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100724       };
100725     }
100726   }
100727   jresult = new Dali::Widget((const Dali::Widget &)result);
100728   return jresult;
100729 }
100730
100731
100732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100733   void * jresult ;
100734   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100735   Dali::Widget result;
100736
100737   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100738
100739   if (!arg1) {
100740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100741     return 0;
100742   }
100743   {
100744     try {
100745       jresult = new Dali::Widget(arg1);
100746     } catch (std::out_of_range& e) {
100747       {
100748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100749       };
100750     } catch (std::exception& e) {
100751       {
100752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100753       };
100754     } catch (...) {
100755       {
100756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100757       };
100758     }
100759   }
100760   return jresult;
100761 }
100762
100763
100764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100765   void * jresult ;
100766   Dali::Widget *result = 0 ;
100767
100768   {
100769     try {
100770       result = (Dali::Widget *)new Dali::Widget();
100771     } catch (std::out_of_range& e) {
100772       {
100773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100774       };
100775     } catch (std::exception& e) {
100776       {
100777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100778       };
100779     } catch (...) {
100780       {
100781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100782       };
100783     }
100784   }
100785   jresult = (void *)result;
100786   return jresult;
100787 }
100788
100789
100790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100791   void * jresult ;
100792   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100793   Dali::Widget *arg2 = 0 ;
100794   Dali::Widget *result = 0 ;
100795
100796   arg1 = (Dali::Widget *)jarg1;
100797   arg2 = (Dali::Widget *)jarg2;
100798   if (!arg2) {
100799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100800     return 0;
100801   }
100802   {
100803     try {
100804       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100805     } catch (std::out_of_range& e) {
100806       {
100807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100808       };
100809     } catch (std::exception& e) {
100810       {
100811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100812       };
100813     } catch (...) {
100814       {
100815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100816       };
100817     }
100818   }
100819   jresult = (void *)result;
100820   return jresult;
100821 }
100822
100823
100824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100825   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100826
100827   arg1 = (Dali::Widget *)jarg1;
100828   {
100829     try {
100830       delete arg1;
100831     } catch (std::out_of_range& e) {
100832       {
100833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100834       };
100835     } catch (std::exception& e) {
100836       {
100837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100838       };
100839     } catch (...) {
100840       {
100841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100842       };
100843     }
100844   }
100845 }
100846
100847
100848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100849   void * jresult ;
100850   SwigDirector_WidgetImpl* result;
100851   {
100852     try {
100853       result = new SwigDirector_WidgetImpl();
100854     } catch (std::out_of_range& e) {
100855       {
100856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100857       };
100858     } catch (std::exception& e) {
100859       {
100860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100861       };
100862     } catch (...) {
100863       {
100864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100865       };
100866     }
100867   }
100868   jresult = result;
100869   return jresult;
100870 }
100871
100872
100873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100874   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100875   std::string *arg2 = 0 ;
100876   Dali::Window arg3 ;
100877   Dali::Window *argp3 ;
100878
100879   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100880   if (!jarg2) {
100881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100882     return ;
100883   }
100884   std::string arg2_str(jarg2);
100885   arg2 = &arg2_str;
100886   argp3 = (Dali::Window *)jarg3;
100887   if (!argp3) {
100888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100889     return ;
100890   }
100891   arg3 = *argp3;
100892   {
100893     try {
100894       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100895     } catch (std::out_of_range& e) {
100896       {
100897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100898       };
100899     } catch (std::exception& e) {
100900       {
100901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100902       };
100903     } catch (...) {
100904       {
100905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100906       };
100907     }
100908   }
100909 }
100910
100911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100912   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100913   std::string *arg2 = 0 ;
100914   Dali::Window arg3 ;
100915   Dali::Window *argp3 ;
100916
100917   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100918   if (!jarg2) {
100919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100920     return ;
100921   }
100922   std::string arg2_str(jarg2);
100923   arg2 = &arg2_str;
100924   argp3 = (Dali::Window *)jarg3;
100925   if (!argp3) {
100926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100927     return ;
100928   }
100929   arg3 = *argp3;
100930   {
100931     try {
100932       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100933     } catch (std::out_of_range& e) {
100934       {
100935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100936       };
100937     } catch (std::exception& e) {
100938       {
100939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100940       };
100941     } catch (...) {
100942       {
100943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100944       };
100945     }
100946   }
100947 }
100948
100949
100950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100951   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100952   std::string *arg2 = 0 ;
100953   Dali::Widget::Termination arg3 ;
100954
100955   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100956   if (!jarg2) {
100957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100958     return ;
100959   }
100960   std::string arg2_str(jarg2);
100961   arg2 = &arg2_str;
100962   arg3 = (Dali::Widget::Termination)jarg3;
100963   {
100964     try {
100965       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100966     } catch (std::out_of_range& e) {
100967       {
100968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100969       };
100970     } catch (std::exception& e) {
100971       {
100972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100973       };
100974     } catch (...) {
100975       {
100976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100977       };
100978     }
100979   }
100980 }
100981
100982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100983   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100984   std::string *arg2 = 0 ;
100985   Dali::Widget::Termination arg3 ;
100986
100987   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100988   if (!jarg2) {
100989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100990     return ;
100991   }
100992   std::string arg2_str(jarg2);
100993   arg2 = &arg2_str;
100994   arg3 = (Dali::Widget::Termination)jarg3;
100995   {
100996     try {
100997       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
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_OnPause(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)->OnPause();
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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101039   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101040
101041   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101042   {
101043     try {
101044       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101045     } catch (std::out_of_range& e) {
101046       {
101047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101048       };
101049     } catch (std::exception& e) {
101050       {
101051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101052       };
101053     } catch (...) {
101054       {
101055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101056       };
101057     }
101058   }
101059 }
101060
101061
101062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101063   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101064
101065   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101066   {
101067     try {
101068       (arg1)->OnResume();
101069     } catch (std::out_of_range& e) {
101070       {
101071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101072       };
101073     } catch (std::exception& e) {
101074       {
101075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101076       };
101077     } catch (...) {
101078       {
101079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101080       };
101081     }
101082   }
101083 }
101084
101085
101086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101087   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101088
101089   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101090   {
101091     try {
101092       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101093     } catch (std::out_of_range& e) {
101094       {
101095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101096       };
101097     } catch (std::exception& e) {
101098       {
101099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101100       };
101101     } catch (...) {
101102       {
101103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101104       };
101105     }
101106   }
101107 }
101108
101109
101110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101111   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101112   Dali::Window arg2 ;
101113   Dali::Window *argp2 ;
101114
101115   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101116   argp2 = (Dali::Window *)jarg2;
101117   if (!argp2) {
101118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101119     return ;
101120   }
101121   arg2 = *argp2;
101122   {
101123     try {
101124       (arg1)->OnResize(arg2);
101125     } catch (std::out_of_range& e) {
101126       {
101127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101128       };
101129     } catch (std::exception& e) {
101130       {
101131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101132       };
101133     } catch (...) {
101134       {
101135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101136       };
101137     }
101138   }
101139 }
101140
101141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101142   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101143   Dali::Window arg2 ;
101144   Dali::Window *argp2 ;
101145
101146   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101147   argp2 = (Dali::Window *)jarg2;
101148   if (!argp2) {
101149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101150     return ;
101151   }
101152   arg2 = *argp2;
101153   {
101154     try {
101155       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101156     } catch (std::out_of_range& e) {
101157       {
101158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101159       };
101160     } catch (std::exception& e) {
101161       {
101162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101163       };
101164     } catch (...) {
101165       {
101166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101167       };
101168     }
101169   }
101170 }
101171
101172
101173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101174   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101175   std::string *arg2 = 0 ;
101176   int arg3 ;
101177
101178   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101179   if (!jarg2) {
101180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101181     return ;
101182   }
101183   std::string arg2_str(jarg2);
101184   arg2 = &arg2_str;
101185   arg3 = (int)jarg3;
101186   {
101187     try {
101188       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101189     } catch (std::out_of_range& e) {
101190       {
101191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101192       };
101193     } catch (std::exception& e) {
101194       {
101195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101196       };
101197     } catch (...) {
101198       {
101199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101200       };
101201     }
101202   }
101203 }
101204
101205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101206   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101207   std::string *arg2 = 0 ;
101208   int arg3 ;
101209
101210   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101211   if (!jarg2) {
101212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101213     return ;
101214   }
101215   std::string arg2_str(jarg2);
101216   arg2 = &arg2_str;
101217   arg3 = (int)jarg3;
101218   {
101219     try {
101220       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101221     } catch (std::out_of_range& e) {
101222       {
101223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101224       };
101225     } catch (std::exception& e) {
101226       {
101227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101228       };
101229     } catch (...) {
101230       {
101231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101232       };
101233     }
101234   }
101235 }
101236
101237
101238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101239   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101240   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101241   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101242
101243   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101244   arg2 = (Dali::SlotObserver *)jarg2;
101245   arg3 = (Dali::CallbackBase *)jarg3;
101246   {
101247     try {
101248       (arg1)->SignalConnected(arg2,arg3);
101249     } catch (std::out_of_range& e) {
101250       {
101251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101252       };
101253     } catch (std::exception& e) {
101254       {
101255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101256       };
101257     } catch (...) {
101258       {
101259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101260       };
101261     }
101262   }
101263 }
101264
101265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101266   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101267   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101268   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101269
101270   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101271   arg2 = (Dali::SlotObserver *)jarg2;
101272   arg3 = (Dali::CallbackBase *)jarg3;
101273   {
101274     try {
101275       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101276     } catch (std::out_of_range& e) {
101277       {
101278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101279       };
101280     } catch (std::exception& e) {
101281       {
101282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101283       };
101284     } catch (...) {
101285       {
101286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101287       };
101288     }
101289   }
101290 }
101291
101292
101293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101294   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101295   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101296   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101297
101298   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101299   arg2 = (Dali::SlotObserver *)jarg2;
101300   arg3 = (Dali::CallbackBase *)jarg3;
101301   {
101302     try {
101303       (arg1)->SignalDisconnected(arg2,arg3);
101304     } catch (std::out_of_range& e) {
101305       {
101306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101307       };
101308     } catch (std::exception& e) {
101309       {
101310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101311       };
101312     } catch (...) {
101313       {
101314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101315       };
101316     }
101317   }
101318 }
101319
101320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101321   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101322   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101323   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101324
101325   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101326   arg2 = (Dali::SlotObserver *)jarg2;
101327   arg3 = (Dali::CallbackBase *)jarg3;
101328   {
101329     try {
101330       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101331     } catch (std::out_of_range& e) {
101332       {
101333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101334       };
101335     } catch (std::exception& e) {
101336       {
101337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101338       };
101339     } catch (...) {
101340       {
101341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101342       };
101343     }
101344   }
101345 }
101346
101347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101348   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101349   std::string *arg2 = 0 ;
101350
101351   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101352   if (!jarg2) {
101353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101354     return ;
101355   }
101356   std::string arg2_str(jarg2);
101357   arg2 = &arg2_str;
101358   {
101359     try {
101360       (arg1)->SetContentInfo((std::string const &)*arg2);
101361     } catch (std::out_of_range& e) {
101362       {
101363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101364       };
101365     } catch (std::exception& e) {
101366       {
101367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101368       };
101369     } catch (...) {
101370       {
101371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101372       };
101373     }
101374   }
101375 }
101376
101377
101378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101379   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101380   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101381
101382   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101383   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101384   {
101385     try {
101386       (arg1)->SetImpl(arg2);
101387     } catch (std::out_of_range& e) {
101388       {
101389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101390       };
101391     } catch (std::exception& e) {
101392       {
101393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101394       };
101395     } catch (...) {
101396       {
101397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101398       };
101399     }
101400   }
101401 }
101402
101403 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) {
101404
101405   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101406   if (director) {
101407     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101408   }
101409 }
101410
101411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101412   void * jresult ;
101413   Dali::Widget *arg1 = 0 ;
101414   SwigDirector_WidgetImpl *result = 0 ;
101415
101416   arg1 = (Dali::Widget *)jarg1;
101417   if (!arg1) {
101418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101419     return 0;
101420   }
101421   {
101422     try {
101423       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101424     } catch (std::out_of_range& e) {
101425       {
101426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101427       };
101428     } catch (std::exception& e) {
101429       {
101430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101431       };
101432     } catch (...) {
101433       {
101434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101435       };
101436     }
101437   }
101438
101439   jresult = (void *)result;
101440   return jresult;
101441 }
101442
101443
101444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101445   void * jresult ;
101446   int *arg1 = (int *) 0 ;
101447   char ***arg2 ;
101448   std::string *arg3 = 0 ;
101449   Dali::WidgetApplication result;
101450   {
101451     int index = 0;
101452     int length = 0;
101453     char *retPtr;
101454     char *nextPtr;
101455     argWidgetC = jarg1;
101456     argWidgetV = new char*[jarg1 + 1];
101457
101458     retPtr = strtok_r( jarg2, " ", &nextPtr);
101459     if( retPtr )
101460     {
101461       length = strlen(retPtr);
101462     }
101463     argWidgetV[index] = new char[length + 1];
101464     if( retPtr )
101465     {
101466       strncpy(argWidgetV[index], retPtr, length);
101467     }
101468     argWidgetV[index][length] = '\0';
101469     index++;
101470
101471     while (index < jarg1)
101472     {
101473       length = 0;
101474       retPtr = strtok_r(NULL, " ", &nextPtr);
101475       if( retPtr )
101476       {
101477         length = strlen(retPtr);
101478       }
101479       argWidgetV[index] = new char[length + 1];
101480       if( retPtr )
101481       {
101482         strncpy(argWidgetV[index], retPtr, length);
101483       }
101484       argWidgetV[index][length] = '\0';
101485       index++;
101486     }
101487
101488     argWidgetV[jarg1] = NULL;
101489     argWidgetC = jarg1;
101490
101491     arg1 = &argWidgetC;
101492     arg2 = &argWidgetV;
101493   }
101494
101495   if (!jarg3) {
101496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101497     return 0;
101498   }
101499   std::string arg3_str(jarg3);
101500   arg3 = &arg3_str;
101501   {
101502     try {
101503       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101504     } catch (std::out_of_range& e) {
101505       {
101506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101507       };
101508     } catch (std::exception& e) {
101509       {
101510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101511       };
101512     } catch (...) {
101513       {
101514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101515       };
101516     }
101517   }
101518   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101519
101520   return jresult;
101521 }
101522
101523
101524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101525   void * jresult ;
101526   Dali::WidgetApplication *result = 0 ;
101527
101528   {
101529     try {
101530       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101531     } catch (std::out_of_range& e) {
101532       {
101533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101534       };
101535     } catch (std::exception& e) {
101536       {
101537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101538       };
101539     } catch (...) {
101540       {
101541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101542       };
101543     }
101544   }
101545   jresult = (void *)result;
101546   return jresult;
101547 }
101548
101549
101550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101551   void * jresult ;
101552   Dali::WidgetApplication *arg1 = 0 ;
101553   Dali::WidgetApplication *result = 0 ;
101554
101555   arg1 = (Dali::WidgetApplication *)jarg1;
101556   if (!arg1) {
101557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101558     return 0;
101559   }
101560   {
101561     try {
101562       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101563     } catch (std::out_of_range& e) {
101564       {
101565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101566       };
101567     } catch (std::exception& e) {
101568       {
101569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101570       };
101571     } catch (...) {
101572       {
101573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101574       };
101575     }
101576   }
101577   jresult = (void *)result;
101578   return jresult;
101579 }
101580
101581
101582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101583   void * jresult ;
101584   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101585   Dali::WidgetApplication *arg2 = 0 ;
101586   Dali::WidgetApplication *result = 0 ;
101587
101588   arg1 = (Dali::WidgetApplication *)jarg1;
101589   arg2 = (Dali::WidgetApplication *)jarg2;
101590   if (!arg2) {
101591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101592     return 0;
101593   }
101594   {
101595     try {
101596       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101597     } catch (std::out_of_range& e) {
101598       {
101599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101600       };
101601     } catch (std::exception& e) {
101602       {
101603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101604       };
101605     } catch (...) {
101606       {
101607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101608       };
101609     }
101610   }
101611   jresult = (void *)result;
101612   return jresult;
101613 }
101614
101615
101616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101617   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101618
101619   arg1 = (Dali::WidgetApplication *)jarg1;
101620   {
101621     try {
101622       delete arg1;
101623       if( argWidgetV )
101624       {
101625         // free string data
101626         for( int i=0; i < argWidgetC+1; i++)
101627         {
101628           delete [] argWidgetV[i];
101629         }
101630         delete [] argWidgetV;
101631       }
101632     } catch (std::out_of_range& e) {
101633       {
101634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101635       };
101636     } catch (std::exception& e) {
101637       {
101638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101639       };
101640     } catch (...) {
101641       {
101642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101643       };
101644     }
101645   }
101646 }
101647
101648
101649 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101650 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101651
101652 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101653 {
101654   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101655   return *widget;
101656 }
101657
101658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101659   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101660   std::string *arg2 = 0 ;
101661
101662   arg1 = (Dali::WidgetApplication *)jarg1;
101663   if (!jarg2) {
101664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101665     return ;
101666   }
101667   std::string arg2_str(*jarg2);
101668   arg2 = &arg2_str;
101669
101670   if(!_CSharpCreateWidgetFunction)
101671   {
101672     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101673   }
101674
101675   {
101676     try {
101677       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101678     } catch (std::out_of_range& e) {
101679       {
101680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101681       };
101682     } catch (std::exception& e) {
101683       {
101684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101685       };
101686     } catch (...) {
101687       {
101688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101689       };
101690     }
101691   }
101692
101693   //Typemap argout in c++ file.
101694   //This will convert c++ string to c# string
101695   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101696 }
101697
101698
101699 //for PixelBuffer and ImageLoading
101700
101701 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101702     return (Dali::BaseHandle *)jarg1;
101703 }
101704
101705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101706   void * jresult ;
101707   unsigned int arg1 ;
101708   unsigned int arg2 ;
101709   Dali::Pixel::Format arg3 ;
101710   Dali::Devel::PixelBuffer result;
101711
101712   arg1 = (unsigned int)jarg1;
101713   arg2 = (unsigned int)jarg2;
101714   arg3 = (Dali::Pixel::Format)jarg3;
101715   {
101716     try {
101717       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101718     } catch (std::out_of_range& e) {
101719       {
101720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101721       };
101722     } catch (std::exception& e) {
101723       {
101724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101725       };
101726     } catch (...) {
101727       {
101728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101729       };
101730     }
101731   }
101732   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101733   return jresult;
101734 }
101735
101736
101737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101738   void * jresult ;
101739   Dali::Devel::PixelBuffer *result = 0 ;
101740
101741   {
101742     try {
101743       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101744     } catch (std::out_of_range& e) {
101745       {
101746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101747       };
101748     } catch (std::exception& e) {
101749       {
101750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101751       };
101752     } catch (...) {
101753       {
101754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101755       };
101756     }
101757   }
101758   jresult = (void *)result;
101759   return jresult;
101760 }
101761
101762
101763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101764   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101765
101766   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101767   {
101768     try {
101769       delete arg1;
101770     } catch (std::out_of_range& e) {
101771       {
101772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101773       };
101774     } catch (std::exception& e) {
101775       {
101776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101777       };
101778     } catch (...) {
101779       {
101780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101781       };
101782     }
101783   }
101784 }
101785
101786
101787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101788   void * jresult ;
101789   Dali::Devel::PixelBuffer *arg1 = 0 ;
101790   Dali::Devel::PixelBuffer *result = 0 ;
101791
101792   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101793   if (!arg1) {
101794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101795     return 0;
101796   }
101797   {
101798     try {
101799       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101800     } catch (std::out_of_range& e) {
101801       {
101802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101803       };
101804     } catch (std::exception& e) {
101805       {
101806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101807       };
101808     } catch (...) {
101809       {
101810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101811       };
101812     }
101813   }
101814   jresult = (void *)result;
101815   return jresult;
101816 }
101817
101818
101819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101820   void * jresult ;
101821   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101822   Dali::Devel::PixelBuffer *arg2 = 0 ;
101823   Dali::Devel::PixelBuffer *result = 0 ;
101824
101825   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101826   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101827   if (!arg2) {
101828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101829     return 0;
101830   }
101831   {
101832     try {
101833       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101834     } catch (std::out_of_range& e) {
101835       {
101836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101837       };
101838     } catch (std::exception& e) {
101839       {
101840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101841       };
101842     } catch (...) {
101843       {
101844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101845       };
101846     }
101847   }
101848   jresult = (void *)result;
101849   return jresult;
101850 }
101851
101852
101853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101854   void * jresult ;
101855   Dali::Devel::PixelBuffer *arg1 = 0 ;
101856   Dali::PixelData result;
101857
101858   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101859   if (!arg1) {
101860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101861     return 0;
101862   }
101863   {
101864     try {
101865       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101866     } catch (std::out_of_range& e) {
101867       {
101868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101869       };
101870     } catch (std::exception& e) {
101871       {
101872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101873       };
101874     } catch (...) {
101875       {
101876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101877       };
101878     }
101879   }
101880   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101881   return jresult;
101882 }
101883
101884
101885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101886   void * jresult ;
101887   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101888   Dali::PixelData result;
101889
101890   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101891   {
101892     try {
101893       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101894     } catch (std::out_of_range& e) {
101895       {
101896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101897       };
101898     } catch (std::exception& e) {
101899       {
101900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101901       };
101902     } catch (...) {
101903       {
101904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101905       };
101906     }
101907   }
101908   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101909   return jresult;
101910 }
101911
101912
101913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101914   void * jresult ;
101915   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101916   unsigned char *result = 0 ;
101917
101918   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101919   {
101920     try {
101921       result = (unsigned char *)(arg1)->GetBuffer();
101922     } catch (std::out_of_range& e) {
101923       {
101924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101925       };
101926     } catch (std::exception& e) {
101927       {
101928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101929       };
101930     } catch (...) {
101931       {
101932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101933       };
101934     }
101935   }
101936   jresult = (void *)result;
101937   return jresult;
101938 }
101939
101940
101941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101942   unsigned int jresult ;
101943   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101944   unsigned int result;
101945
101946   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101947   {
101948     try {
101949       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101950     } catch (std::out_of_range& e) {
101951       {
101952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101953       };
101954     } catch (std::exception& e) {
101955       {
101956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101957       };
101958     } catch (...) {
101959       {
101960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101961       };
101962     }
101963   }
101964   jresult = result;
101965   return jresult;
101966 }
101967
101968
101969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101970   unsigned int jresult ;
101971   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101972   unsigned int result;
101973
101974   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101975   {
101976     try {
101977       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101978     } catch (std::out_of_range& e) {
101979       {
101980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101981       };
101982     } catch (std::exception& e) {
101983       {
101984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101985       };
101986     } catch (...) {
101987       {
101988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101989       };
101990     }
101991   }
101992   jresult = result;
101993   return jresult;
101994 }
101995
101996
101997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101998   int jresult ;
101999   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102000   Dali::Pixel::Format result;
102001
102002   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102003   {
102004     try {
102005       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102006     } catch (std::out_of_range& e) {
102007       {
102008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102009       };
102010     } catch (std::exception& e) {
102011       {
102012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102013       };
102014     } catch (...) {
102015       {
102016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102017       };
102018     }
102019   }
102020   jresult = (int)result;
102021   return jresult;
102022 }
102023
102024
102025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102026   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102027   Dali::Devel::PixelBuffer arg2 ;
102028   float arg3 ;
102029   bool arg4 ;
102030   Dali::Devel::PixelBuffer *argp2 ;
102031
102032   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102033   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102034   if (!argp2) {
102035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102036     return ;
102037   }
102038   arg2 = *argp2;
102039   arg3 = (float)jarg3;
102040   arg4 = jarg4 ? true : false;
102041   {
102042     try {
102043       (arg1)->ApplyMask(arg2,arg3,arg4);
102044     } catch (std::out_of_range& e) {
102045       {
102046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102047       };
102048     } catch (std::exception& e) {
102049       {
102050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102051       };
102052     } catch (...) {
102053       {
102054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102055       };
102056     }
102057   }
102058 }
102059
102060
102061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102062   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102063   Dali::Devel::PixelBuffer arg2 ;
102064   float arg3 ;
102065   Dali::Devel::PixelBuffer *argp2 ;
102066
102067   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102068   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102069   if (!argp2) {
102070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102071     return ;
102072   }
102073   arg2 = *argp2;
102074   arg3 = (float)jarg3;
102075   {
102076     try {
102077       (arg1)->ApplyMask(arg2,arg3);
102078     } catch (std::out_of_range& e) {
102079       {
102080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102081       };
102082     } catch (std::exception& e) {
102083       {
102084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102085       };
102086     } catch (...) {
102087       {
102088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102089       };
102090     }
102091   }
102092 }
102093
102094
102095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102096   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102097   Dali::Devel::PixelBuffer arg2 ;
102098   Dali::Devel::PixelBuffer *argp2 ;
102099
102100   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102101   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102102   if (!argp2) {
102103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102104     return ;
102105   }
102106   arg2 = *argp2;
102107   {
102108     try {
102109       (arg1)->ApplyMask(arg2);
102110     } catch (std::out_of_range& e) {
102111       {
102112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102113       };
102114     } catch (std::exception& e) {
102115       {
102116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102117       };
102118     } catch (...) {
102119       {
102120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102121       };
102122     }
102123   }
102124 }
102125
102126
102127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102128   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102129   float arg2 ;
102130
102131   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102132   arg2 = (float)jarg2;
102133   {
102134     try {
102135       (arg1)->ApplyGaussianBlur(arg2);
102136     } catch (std::out_of_range& e) {
102137       {
102138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102139       };
102140     } catch (std::exception& e) {
102141       {
102142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102143       };
102144     } catch (...) {
102145       {
102146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102147       };
102148     }
102149   }
102150 }
102151
102152
102153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102154   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102155   uint16_t arg2 ;
102156   uint16_t arg3 ;
102157   uint16_t arg4 ;
102158   uint16_t arg5 ;
102159
102160   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102161   arg2 = (uint16_t)jarg2;
102162   arg3 = (uint16_t)jarg3;
102163   arg4 = (uint16_t)jarg4;
102164   arg5 = (uint16_t)jarg5;
102165   {
102166     try {
102167       (arg1)->Crop(arg2,arg3,arg4,arg5);
102168     } catch (std::out_of_range& e) {
102169       {
102170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102171       };
102172     } catch (std::exception& e) {
102173       {
102174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102175       };
102176     } catch (...) {
102177       {
102178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102179       };
102180     }
102181   }
102182 }
102183
102184
102185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102186   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102187   uint16_t arg2 ;
102188   uint16_t arg3 ;
102189
102190   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102191   arg2 = (uint16_t)jarg2;
102192   arg3 = (uint16_t)jarg3;
102193   {
102194     try {
102195       (arg1)->Resize(arg2,arg3);
102196     } catch (std::out_of_range& e) {
102197       {
102198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102199       };
102200     } catch (std::exception& e) {
102201       {
102202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102203       };
102204     } catch (...) {
102205       {
102206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102207       };
102208     }
102209   }
102210 }
102211
102212
102213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102214   void * jresult ;
102215   std::string *arg1 = 0 ;
102216   Dali::ImageDimensions arg2 ;
102217   Dali::FittingMode::Type arg3 ;
102218   Dali::SamplingMode::Type arg4 ;
102219   bool arg5 ;
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   arg5 = jarg5 ? true : false;
102238   {
102239     try {
102240       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102241     } catch (std::out_of_range& e) {
102242       {
102243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102244       };
102245     } catch (std::exception& e) {
102246       {
102247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102248       };
102249     } catch (...) {
102250       {
102251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102252       };
102253     }
102254   }
102255   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102256
102257   return jresult;
102258 }
102259
102260
102261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102262   void * jresult ;
102263   std::string *arg1 = 0 ;
102264   Dali::ImageDimensions arg2 ;
102265   Dali::FittingMode::Type arg3 ;
102266   Dali::SamplingMode::Type arg4 ;
102267   Dali::ImageDimensions *argp2 ;
102268   Dali::Devel::PixelBuffer result;
102269
102270   if (!jarg1) {
102271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102272     return 0;
102273   }
102274   std::string arg1_str(jarg1);
102275   arg1 = &arg1_str;
102276   argp2 = (Dali::ImageDimensions *)jarg2;
102277   if (!argp2) {
102278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102279     return 0;
102280   }
102281   arg2 = *argp2;
102282   arg3 = (Dali::FittingMode::Type)jarg3;
102283   arg4 = (Dali::SamplingMode::Type)jarg4;
102284   {
102285     try {
102286       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102287     } catch (std::out_of_range& e) {
102288       {
102289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102290       };
102291     } catch (std::exception& e) {
102292       {
102293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102294       };
102295     } catch (...) {
102296       {
102297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102298       };
102299     }
102300   }
102301   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102302
102303   return jresult;
102304 }
102305
102306
102307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102308   void * jresult ;
102309   std::string *arg1 = 0 ;
102310   Dali::ImageDimensions arg2 ;
102311   Dali::FittingMode::Type arg3 ;
102312   Dali::ImageDimensions *argp2 ;
102313   Dali::Devel::PixelBuffer result;
102314
102315   if (!jarg1) {
102316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102317     return 0;
102318   }
102319   std::string arg1_str(jarg1);
102320   arg1 = &arg1_str;
102321   argp2 = (Dali::ImageDimensions *)jarg2;
102322   if (!argp2) {
102323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102324     return 0;
102325   }
102326   arg2 = *argp2;
102327   arg3 = (Dali::FittingMode::Type)jarg3;
102328   {
102329     try {
102330       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102331     } catch (std::out_of_range& e) {
102332       {
102333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102334       };
102335     } catch (std::exception& e) {
102336       {
102337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102338       };
102339     } catch (...) {
102340       {
102341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102342       };
102343     }
102344   }
102345   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102346
102347   return jresult;
102348 }
102349
102350
102351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102352   void * jresult ;
102353   std::string *arg1 = 0 ;
102354   Dali::ImageDimensions arg2 ;
102355   Dali::ImageDimensions *argp2 ;
102356   Dali::Devel::PixelBuffer result;
102357
102358   if (!jarg1) {
102359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102360     return 0;
102361   }
102362   std::string arg1_str(jarg1);
102363   arg1 = &arg1_str;
102364   argp2 = (Dali::ImageDimensions *)jarg2;
102365   if (!argp2) {
102366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102367     return 0;
102368   }
102369   arg2 = *argp2;
102370   {
102371     try {
102372       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102373     } catch (std::out_of_range& e) {
102374       {
102375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102376       };
102377     } catch (std::exception& e) {
102378       {
102379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102380       };
102381     } catch (...) {
102382       {
102383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102384       };
102385     }
102386   }
102387   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102388
102389   return jresult;
102390 }
102391
102392
102393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102394   void * jresult ;
102395   std::string *arg1 = 0 ;
102396   Dali::Devel::PixelBuffer result;
102397
102398   if (!jarg1) {
102399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102400     return 0;
102401   }
102402   std::string arg1_str(jarg1);
102403   arg1 = &arg1_str;
102404   {
102405     try {
102406       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102407     } catch (std::out_of_range& e) {
102408       {
102409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102410       };
102411     } catch (std::exception& e) {
102412       {
102413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102414       };
102415     } catch (...) {
102416       {
102417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102418       };
102419     }
102420   }
102421   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102422
102423   return jresult;
102424 }
102425
102426
102427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102428   void * jresult ;
102429   std::string *arg1 = 0 ;
102430   Dali::ImageDimensions arg2 ;
102431   Dali::FittingMode::Type arg3 ;
102432   Dali::SamplingMode::Type arg4 ;
102433   bool arg5 ;
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   arg5 = jarg5 ? true : false;
102452   {
102453     try {
102454       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102455     } catch (std::out_of_range& e) {
102456       {
102457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102458       };
102459     } catch (std::exception& e) {
102460       {
102461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102462       };
102463     } catch (...) {
102464       {
102465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102466       };
102467     }
102468   }
102469   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102470
102471   return jresult;
102472 }
102473
102474
102475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102476   void * jresult ;
102477   std::string *arg1 = 0 ;
102478   Dali::ImageDimensions arg2 ;
102479   Dali::FittingMode::Type arg3 ;
102480   Dali::SamplingMode::Type arg4 ;
102481   Dali::ImageDimensions *argp2 ;
102482   Dali::ImageDimensions result;
102483
102484   if (!jarg1) {
102485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102486     return 0;
102487   }
102488   std::string arg1_str(jarg1);
102489   arg1 = &arg1_str;
102490   argp2 = (Dali::ImageDimensions *)jarg2;
102491   if (!argp2) {
102492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102493     return 0;
102494   }
102495   arg2 = *argp2;
102496   arg3 = (Dali::FittingMode::Type)jarg3;
102497   arg4 = (Dali::SamplingMode::Type)jarg4;
102498   {
102499     try {
102500       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102501     } catch (std::out_of_range& e) {
102502       {
102503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102504       };
102505     } catch (std::exception& e) {
102506       {
102507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102508       };
102509     } catch (...) {
102510       {
102511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102512       };
102513     }
102514   }
102515   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102516
102517   return jresult;
102518 }
102519
102520
102521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102522   void * jresult ;
102523   std::string *arg1 = 0 ;
102524   Dali::ImageDimensions arg2 ;
102525   Dali::FittingMode::Type arg3 ;
102526   Dali::ImageDimensions *argp2 ;
102527   Dali::ImageDimensions result;
102528
102529   if (!jarg1) {
102530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102531     return 0;
102532   }
102533   std::string arg1_str(jarg1);
102534   arg1 = &arg1_str;
102535   argp2 = (Dali::ImageDimensions *)jarg2;
102536   if (!argp2) {
102537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102538     return 0;
102539   }
102540   arg2 = *argp2;
102541   arg3 = (Dali::FittingMode::Type)jarg3;
102542   {
102543     try {
102544       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102545     } catch (std::out_of_range& e) {
102546       {
102547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102548       };
102549     } catch (std::exception& e) {
102550       {
102551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102552       };
102553     } catch (...) {
102554       {
102555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102556       };
102557     }
102558   }
102559   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102560
102561   return jresult;
102562 }
102563
102564
102565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102566   void * jresult ;
102567   std::string *arg1 = 0 ;
102568   Dali::ImageDimensions arg2 ;
102569   Dali::ImageDimensions *argp2 ;
102570   Dali::ImageDimensions result;
102571
102572   if (!jarg1) {
102573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102574     return 0;
102575   }
102576   std::string arg1_str(jarg1);
102577   arg1 = &arg1_str;
102578   argp2 = (Dali::ImageDimensions *)jarg2;
102579   if (!argp2) {
102580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102581     return 0;
102582   }
102583   arg2 = *argp2;
102584   {
102585     try {
102586       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102587     } catch (std::out_of_range& e) {
102588       {
102589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102590       };
102591     } catch (std::exception& e) {
102592       {
102593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102594       };
102595     } catch (...) {
102596       {
102597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102598       };
102599     }
102600   }
102601   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102602
102603   return jresult;
102604 }
102605
102606
102607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102608   void * jresult ;
102609   std::string *arg1 = 0 ;
102610   Dali::ImageDimensions result;
102611
102612   if (!jarg1) {
102613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102614     return 0;
102615   }
102616   std::string arg1_str(jarg1);
102617   arg1 = &arg1_str;
102618   {
102619     try {
102620       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102621     } catch (std::out_of_range& e) {
102622       {
102623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102624       };
102625     } catch (std::exception& e) {
102626       {
102627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102628       };
102629     } catch (...) {
102630       {
102631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102632       };
102633     }
102634   }
102635   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102636
102637   return jresult;
102638 }
102639
102640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102641   void * jresult ;
102642   std::string *arg1 = 0 ;
102643   Dali::ImageDimensions result;
102644
102645   if (!jarg1) {
102646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102647     return 0;
102648   }
102649   std::string arg1_str(jarg1);
102650   arg1 = &arg1_str;
102651   {
102652     try {
102653       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
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::ImageDimensions((const Dali::ImageDimensions &)result);
102669
102670   return jresult;
102671 }
102672
102673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102674   void * jresult ;
102675   std::string *arg1 = 0 ;
102676   Dali::ImageDimensions arg2 ;
102677   Dali::FittingMode::Type arg3 ;
102678   Dali::SamplingMode::Type arg4 ;
102679   bool arg5 ;
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   arg5 = jarg5 ? true : false;
102698   {
102699     try {
102700       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102701     } catch (std::out_of_range& e) {
102702       {
102703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102704       };
102705     } catch (std::exception& e) {
102706       {
102707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102708       };
102709     } catch (...) {
102710       {
102711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102712       };
102713     }
102714   }
102715   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102716
102717   return jresult;
102718 }
102719
102720
102721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102722   void * jresult ;
102723   std::string *arg1 = 0 ;
102724   Dali::ImageDimensions arg2 ;
102725   Dali::FittingMode::Type arg3 ;
102726   Dali::SamplingMode::Type arg4 ;
102727   Dali::ImageDimensions *argp2 ;
102728   Dali::Devel::PixelBuffer result;
102729
102730   if (!jarg1) {
102731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102732     return 0;
102733   }
102734   std::string arg1_str(jarg1);
102735   arg1 = &arg1_str;
102736   argp2 = (Dali::ImageDimensions *)jarg2;
102737   if (!argp2) {
102738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102739     return 0;
102740   }
102741   arg2 = *argp2;
102742   arg3 = (Dali::FittingMode::Type)jarg3;
102743   arg4 = (Dali::SamplingMode::Type)jarg4;
102744   {
102745     try {
102746       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102747     } catch (std::out_of_range& e) {
102748       {
102749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102750       };
102751     } catch (std::exception& e) {
102752       {
102753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102754       };
102755     } catch (...) {
102756       {
102757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102758       };
102759     }
102760   }
102761   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102762
102763   return jresult;
102764 }
102765
102766
102767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102768   void * jresult ;
102769   std::string *arg1 = 0 ;
102770   Dali::ImageDimensions arg2 ;
102771   Dali::FittingMode::Type arg3 ;
102772   Dali::ImageDimensions *argp2 ;
102773   Dali::Devel::PixelBuffer result;
102774
102775   if (!jarg1) {
102776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102777     return 0;
102778   }
102779   std::string arg1_str(jarg1);
102780   arg1 = &arg1_str;
102781   argp2 = (Dali::ImageDimensions *)jarg2;
102782   if (!argp2) {
102783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102784     return 0;
102785   }
102786   arg2 = *argp2;
102787   arg3 = (Dali::FittingMode::Type)jarg3;
102788   {
102789     try {
102790       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102791     } catch (std::out_of_range& e) {
102792       {
102793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102794       };
102795     } catch (std::exception& e) {
102796       {
102797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102798       };
102799     } catch (...) {
102800       {
102801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102802       };
102803     }
102804   }
102805   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102806
102807   return jresult;
102808 }
102809
102810
102811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102812   void * jresult ;
102813   std::string *arg1 = 0 ;
102814   Dali::ImageDimensions arg2 ;
102815   Dali::ImageDimensions *argp2 ;
102816   Dali::Devel::PixelBuffer result;
102817
102818   if (!jarg1) {
102819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102820     return 0;
102821   }
102822   std::string arg1_str(jarg1);
102823   arg1 = &arg1_str;
102824   argp2 = (Dali::ImageDimensions *)jarg2;
102825   if (!argp2) {
102826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102827     return 0;
102828   }
102829   arg2 = *argp2;
102830   {
102831     try {
102832       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102833     } catch (std::out_of_range& e) {
102834       {
102835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102836       };
102837     } catch (std::exception& e) {
102838       {
102839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102840       };
102841     } catch (...) {
102842       {
102843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102844       };
102845     }
102846   }
102847   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102848
102849   return jresult;
102850 }
102851
102852
102853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102854   void * jresult ;
102855   std::string *arg1 = 0 ;
102856   Dali::Devel::PixelBuffer result;
102857
102858   if (!jarg1) {
102859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102860     return 0;
102861   }
102862   std::string arg1_str(jarg1);
102863   arg1 = &arg1_str;
102864   {
102865     try {
102866       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102867     } catch (std::out_of_range& e) {
102868       {
102869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102870       };
102871     } catch (std::exception& e) {
102872       {
102873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102874       };
102875     } catch (...) {
102876       {
102877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102878       };
102879     }
102880   }
102881   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102882
102883   return jresult;
102884 }
102885
102886
102887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102888   void * jresult ;
102889   Dali::Toolkit::WebView result;
102890
102891   {
102892     try {
102893       result = Dali::Toolkit::WebView::New();
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_WebView_New_2(char * jarg1, char * jarg2) {
102917   void * jresult ;
102918   Dali::Toolkit::WebView result;
102919
102920   std::string *arg1;
102921   std::string *arg2;
102922
102923   if (!jarg1) {
102924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102925     return 0;
102926   }
102927   if (!jarg2) {
102928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102929     return 0;
102930   }
102931
102932   std::string jarg1_str = std::string(jarg1);
102933   std::string jarg2_str = std::string(jarg2);
102934
102935   arg1 = &jarg1_str;
102936   arg2 = &jarg2_str;
102937
102938   {
102939     try {
102940       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102941     } catch (std::out_of_range& e) {
102942       {
102943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102944       };
102945     } catch (std::exception& e) {
102946       {
102947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102948       };
102949     } catch (Dali::DaliException e) {
102950       {
102951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102952       };
102953     } catch (...) {
102954       {
102955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102956       };
102957     }
102958   }
102959   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102960   return jresult;
102961 }
102962
102963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102964   void * jresult ;
102965   Dali::Toolkit::WebView *arg1 = 0 ;
102966   Dali::Toolkit::WebView *result = 0 ;
102967
102968   arg1 = (Dali::Toolkit::WebView *)jarg1;
102969   if (!arg1) {
102970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102971     return 0;
102972   }
102973   {
102974     try {
102975       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102976     } catch (std::out_of_range& e) {
102977       {
102978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102979       };
102980     } catch (std::exception& e) {
102981       {
102982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102983       };
102984     } catch (Dali::DaliException e) {
102985       {
102986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102987       };
102988     } catch (...) {
102989       {
102990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102991       };
102992     }
102993   }
102994   jresult = (void *)result;
102995   return jresult;
102996 }
102997
102998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102999   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103000   arg1 = (Dali::Toolkit::WebView *)jarg1;
103001   {
103002     try {
103003       delete arg1;
103004     } catch (std::out_of_range& e) {
103005       {
103006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103007       };
103008     } catch (std::exception& e) {
103009       {
103010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103011       };
103012     } catch (Dali::DaliException e) {
103013       {
103014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103015       };
103016     } catch (...) {
103017       {
103018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103019       };
103020     }
103021   }
103022 }
103023
103024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103025   void * jresult ;
103026   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103027   Dali::Toolkit::WebView *arg2 = 0 ;
103028   Dali::Toolkit::WebView *result = 0 ;
103029
103030   arg1 = (Dali::Toolkit::WebView *)jarg1;
103031   arg2 = (Dali::Toolkit::WebView *)jarg2;
103032   if (!arg2) {
103033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103034     return 0;
103035   }
103036   {
103037     try {
103038       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103039     } catch (std::out_of_range& e) {
103040       {
103041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103042       };
103043     } catch (std::exception& e) {
103044       {
103045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103046       };
103047     } catch (Dali::DaliException e) {
103048       {
103049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103050       };
103051     } catch (...) {
103052       {
103053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103054       };
103055     }
103056   }
103057   jresult = (void *)result;
103058   return jresult;
103059 }
103060
103061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103062   void * jresult ;
103063   Dali::BaseHandle arg1 ;
103064   Dali::BaseHandle *argp1 ;
103065   Dali::Toolkit::WebView result;
103066
103067   argp1 = (Dali::BaseHandle *)jarg1;
103068   if (!argp1) {
103069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103070     return 0;
103071   }
103072   arg1 = *argp1;
103073   {
103074     try {
103075       result = Dali::Toolkit::WebView::DownCast(arg1);
103076     } catch (std::out_of_range& e) {
103077       {
103078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103079       };
103080     } catch (std::exception& e) {
103081       {
103082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103083       };
103084     } catch (Dali::DaliException e) {
103085       {
103086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103087       };
103088     } catch (...) {
103089       {
103090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103091       };
103092     }
103093   }
103094   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103095   return jresult;
103096 }
103097
103098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
103099   return (int) Dali::Toolkit::WebView::Property::URL;
103100 }
103101
103102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
103103   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
103104 }
103105
103106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
103107   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
103108 }
103109
103110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
103111   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
103112 }
103113
103114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
103115   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
103116 }
103117
103118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
103119   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
103120 }
103121
103122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
103123   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
103124 }
103125
103126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
103127   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
103128 }
103129
103130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103131   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103132   std::string *arg2;
103133
103134   arg1 = (Dali::Toolkit::WebView *)jarg1;
103135
103136   if (!jarg2) {
103137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103138     return;
103139   }
103140
103141   std::string jarg2str = std::string(jarg2);
103142   arg2 = &jarg2str;
103143   {
103144     try {
103145       (arg1)->LoadUrl((std::string const &)*arg2);
103146     } catch (std::out_of_range& e) {
103147       {
103148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103149       };
103150     } catch (std::exception& e) {
103151       {
103152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103153       };
103154     } catch (Dali::DaliException e) {
103155       {
103156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103157       };
103158     } catch (...) {
103159       {
103160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103161       };
103162     }
103163   }
103164 }
103165
103166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103167   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103168   std::string *arg2;
103169
103170   arg1 = (Dali::Toolkit::WebView *)jarg1;
103171   if (!jarg2) {
103172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103173     return;
103174   }
103175   std::string jarg2str = std::string(jarg2);
103176   arg2 = &jarg2str;
103177   {
103178     try {
103179       (arg1)->LoadHTMLString((std::string const &)*arg2);
103180     } catch (std::out_of_range& e) {
103181       {
103182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103183       };
103184     } catch (std::exception& e) {
103185       {
103186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103187       };
103188     } catch (Dali::DaliException e) {
103189       {
103190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103191       };
103192     } catch (...) {
103193       {
103194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103195       };
103196     }
103197   }
103198 }
103199
103200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103201   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103202
103203   arg1 = (Dali::Toolkit::WebView *)jarg1;
103204   {
103205     try {
103206       (arg1)->Reload();
103207     } catch (std::out_of_range& e) {
103208       {
103209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103210       };
103211     } catch (std::exception& e) {
103212       {
103213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103214       };
103215     } catch (Dali::DaliException e) {
103216       {
103217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103218       };
103219     } catch (...) {
103220       {
103221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103222       };
103223     }
103224   }
103225 }
103226
103227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103228   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103229
103230   arg1 = (Dali::Toolkit::WebView *)jarg1;
103231   {
103232     try {
103233       (arg1)->StopLoading();
103234     } catch (std::out_of_range& e) {
103235       {
103236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103237       };
103238     } catch (std::exception& e) {
103239       {
103240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103241       };
103242     } catch (Dali::DaliException e) {
103243       {
103244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103245       };
103246     } catch (...) {
103247       {
103248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103249       };
103250     }
103251   }
103252 }
103253
103254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
103255   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103256
103257   arg1 = (Dali::Toolkit::WebView *)jarg1;
103258   {
103259     try {
103260       (arg1)->Suspend();
103261     } catch (std::out_of_range& e) {
103262       {
103263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103264       };
103265     } catch (std::exception& e) {
103266       {
103267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103268       };
103269     } catch (Dali::DaliException e) {
103270       {
103271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103272       };
103273     } catch (...) {
103274       {
103275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103276       };
103277     }
103278   }
103279 }
103280
103281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
103282   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103283
103284   arg1 = (Dali::Toolkit::WebView *)jarg1;
103285   {
103286     try {
103287       (arg1)->Resume();
103288     } catch (std::out_of_range& e) {
103289       {
103290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103291       };
103292     } catch (std::exception& e) {
103293       {
103294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103295       };
103296     } catch (Dali::DaliException e) {
103297       {
103298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103299       };
103300     } catch (...) {
103301       {
103302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103303       };
103304     }
103305   }
103306 }
103307
103308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103309   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103310
103311   arg1 = (Dali::Toolkit::WebView *)jarg1;
103312   {
103313     try {
103314       (arg1)->GoBack();
103315     } catch (std::out_of_range& e) {
103316       {
103317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103318       };
103319     } catch (std::exception& e) {
103320       {
103321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103322       };
103323     } catch (Dali::DaliException e) {
103324       {
103325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103326       };
103327     } catch (...) {
103328       {
103329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103330       };
103331     }
103332   }
103333 }
103334
103335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103336   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103337
103338   arg1 = (Dali::Toolkit::WebView *)jarg1;
103339   {
103340     try {
103341       (arg1)->GoForward();
103342     } catch (std::out_of_range& e) {
103343       {
103344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103345       };
103346     } catch (std::exception& e) {
103347       {
103348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103349       };
103350     } catch (Dali::DaliException e) {
103351       {
103352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103353       };
103354     } catch (...) {
103355       {
103356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103357       };
103358     }
103359   }
103360 }
103361
103362 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103363   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103364   bool ret;
103365
103366   arg1 = (Dali::Toolkit::WebView *)jarg1;
103367   {
103368     try {
103369       ret = (arg1)->CanGoBack();
103370     } catch (std::out_of_range& e) {
103371       {
103372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103373       };
103374     } catch (std::exception& e) {
103375       {
103376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103377       };
103378     } catch (Dali::DaliException e) {
103379       {
103380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103381       };
103382     } catch (...) {
103383       {
103384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103385       };
103386     }
103387   }
103388   return ret;
103389 }
103390
103391 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103392   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103393   bool ret;
103394
103395   arg1 = (Dali::Toolkit::WebView *)jarg1;
103396   {
103397     try {
103398       ret = (arg1)->CanGoForward();
103399     } catch (std::out_of_range& e) {
103400       {
103401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103402       };
103403     } catch (std::exception& e) {
103404       {
103405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103406       };
103407     } catch (Dali::DaliException e) {
103408       {
103409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103410       };
103411     } catch (...) {
103412       {
103413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103414       };
103415     }
103416   }
103417   return ret;
103418 }
103419
103420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
103421   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103422   std::string *arg2;
103423
103424   arg1 = (Dali::Toolkit::WebView *)jarg1;
103425   if (!jarg2) {
103426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103427     return;
103428   }
103429   std::string jarg2_str = std::string(jarg2);
103430   arg2 = &jarg2_str;
103431
103432   {
103433     try {
103434       if (jarg3) {
103435         void (*handler)(char*) = (void (*)(char*)) jarg3;
103436         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
103437           handler(SWIG_csharp_string_callback(result.c_str()));
103438         });
103439       } else {
103440         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
103441       }
103442     } catch (std::out_of_range& e) {
103443       {
103444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103445       };
103446     } catch (std::exception& e) {
103447       {
103448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103449       };
103450     } catch (Dali::DaliException e) {
103451       {
103452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103453       };
103454     } catch (...) {
103455       {
103456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103457       };
103458     }
103459   }
103460 }
103461
103462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103463 {
103464   if (!jarg2) {
103465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103466     return;
103467   }
103468
103469   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103470   std::string exposedObjectName = jarg2;
103471   void (*handler)(char*) = (void (*)(char*)) jarg3;
103472
103473   {
103474     try {
103475       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103476         handler(SWIG_csharp_string_callback(message.c_str()));
103477       });
103478     } catch (std::out_of_range& e) {
103479       {
103480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103481       };
103482     } catch (std::exception& e) {
103483       {
103484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103485       };
103486     } catch (Dali::DaliException e) {
103487       {
103488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103489       };
103490     } catch (...) {
103491       {
103492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103493       };
103494     }
103495   }
103496 }
103497
103498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103499   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103500
103501   arg1 = (Dali::Toolkit::WebView *)jarg1;
103502   {
103503     try {
103504       (arg1)->ClearHistory();
103505     } catch (std::out_of_range& e) {
103506       {
103507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103508       };
103509     } catch (std::exception& e) {
103510       {
103511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103512       };
103513     } catch (Dali::DaliException e) {
103514       {
103515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103516       };
103517     } catch (...) {
103518       {
103519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103520       };
103521     }
103522   }
103523 }
103524
103525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103526   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103527
103528   arg1 = (Dali::Toolkit::WebView *)jarg1;
103529   {
103530     try {
103531       (arg1)->ClearCache();
103532     } catch (std::out_of_range& e) {
103533       {
103534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103535       };
103536     } catch (std::exception& e) {
103537       {
103538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103539       };
103540     } catch (Dali::DaliException e) {
103541       {
103542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103543       };
103544     } catch (...) {
103545       {
103546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103547       };
103548     }
103549   }
103550 }
103551
103552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
103553   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103554
103555   arg1 = (Dali::Toolkit::WebView *)jarg1;
103556   {
103557     try {
103558       (arg1)->ClearCookies();
103559     } catch (std::out_of_range& e) {
103560       {
103561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103562       };
103563     } catch (std::exception& e) {
103564       {
103565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103566       };
103567     } catch (Dali::DaliException e) {
103568       {
103569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103570       };
103571     } catch (...) {
103572       {
103573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103574       };
103575     }
103576   }
103577 }
103578
103579 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103580     return (Dali::Toolkit::Control *)jarg1;
103581 }
103582
103583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
103584   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103585   SignalConverter::WebViewPageLoadSignal* result = NULL;
103586   {
103587     try {
103588       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
103589     } catch (std::out_of_range& e) {
103590       {
103591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103592       };
103593     } catch (std::exception& e) {
103594       {
103595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103596       };
103597     } catch (Dali::DaliException e) {
103598       {
103599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103600       };
103601     } catch (...) {
103602       {
103603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103604       };
103605     }
103606   }
103607   return (void*) result;
103608 }
103609
103610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
103611   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103612   SignalConverter::WebViewPageLoadSignal* result = NULL;
103613   {
103614     try {
103615       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
103616     } catch (std::out_of_range& e) {
103617       {
103618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103619       };
103620     } catch (std::exception& e) {
103621       {
103622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103623       };
103624     } catch (Dali::DaliException e) {
103625       {
103626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103627       };
103628     } catch (...) {
103629       {
103630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103631       };
103632     }
103633   }
103634   return (void*) result;
103635 }
103636
103637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
103638 {
103639   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103640   {
103641     try {
103642       delete object;
103643     } catch (std::out_of_range& e) {
103644       {
103645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103646       };
103647     } catch (std::exception& e) {
103648       {
103649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103650       };
103651     } catch (Dali::DaliException e) {
103652       {
103653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103654       };
103655     } catch (...) {
103656       {
103657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103658       };
103659     }
103660   }
103661 }
103662
103663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
103664 {
103665   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103666   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103667   {
103668     try {
103669       proxy->Connect(callback);
103670     } catch (std::out_of_range& e) {
103671       {
103672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103673       };
103674     } catch (std::exception& e) {
103675       {
103676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103677       };
103678     } catch (Dali::DaliException e) {
103679       {
103680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103681       };
103682     } catch (...) {
103683       {
103684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103685       };
103686     }
103687   }
103688 }
103689
103690
103691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
103692   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103693   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103694   {
103695     try {
103696       proxy->Disconnect(callback);
103697     } catch (std::out_of_range& e) {
103698       {
103699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103700       };
103701     } catch (std::exception& e) {
103702       {
103703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103704       };
103705     } catch (Dali::DaliException e) {
103706       {
103707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103708       };
103709     } catch (...) {
103710       {
103711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103712       };
103713     }
103714   }
103715 }
103716
103717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
103718   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103719   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
103720   {
103721     try {
103722       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
103723     } catch (std::out_of_range& e) {
103724       {
103725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103726       };
103727     } catch (std::exception& e) {
103728       {
103729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103730       };
103731     } catch (Dali::DaliException e) {
103732       {
103733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103734       };
103735     } catch (...) {
103736       {
103737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103738       };
103739     }
103740   }
103741   return (void*) result;
103742 }
103743
103744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
103745 {
103746   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103747   {
103748     try {
103749       delete object;
103750     } catch (std::out_of_range& e) {
103751       {
103752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103753       };
103754     } catch (std::exception& e) {
103755       {
103756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103757       };
103758     } catch (Dali::DaliException e) {
103759       {
103760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103761       };
103762     } catch (...) {
103763       {
103764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103765       };
103766     }
103767   }
103768 }
103769
103770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
103771 {
103772   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103773   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103774   {
103775     try {
103776       proxy->Connect(callback);
103777     } catch (std::out_of_range& e) {
103778       {
103779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103780       };
103781     } catch (std::exception& e) {
103782       {
103783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103784       };
103785     } catch (Dali::DaliException e) {
103786       {
103787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103788       };
103789     } catch (...) {
103790       {
103791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103792       };
103793     }
103794   }
103795 }
103796
103797
103798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103799   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103800   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103801   {
103802     try {
103803       proxy->Disconnect(callback);
103804     } catch (std::out_of_range& e) {
103805       {
103806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103807       };
103808     } catch (std::exception& e) {
103809       {
103810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103811       };
103812     } catch (Dali::DaliException e) {
103813       {
103814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103815       };
103816     } catch (...) {
103817       {
103818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103819       };
103820     }
103821   }
103822 }
103823
103824 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103825   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103826   char * jresult = SWIG_csharp_string_callback((const char *)result);
103827   return jresult;
103828 }
103829
103830 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103831   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103832   return result;
103833 }
103834
103835 #ifdef __cplusplus
103836 }
103837 #endif
103838