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_GetFrameBufferImage(void * jarg1, char * jarg2) {
62042   void * jresult ;
62043   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62044   std::string *arg2 = 0 ;
62045   Dali::FrameBufferImage 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)->GetFrameBufferImage((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::FrameBufferImage((const Dali::FrameBufferImage &)result);
62077
62078   //argout typemap for const std::string&
62079
62080   return jresult;
62081 }
62082
62083
62084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62085   void * jresult ;
62086   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62087   std::string *arg2 = 0 ;
62088   Dali::Path 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)->GetPath((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::Path((const Dali::Path &)result);
62120
62121   //argout typemap for const std::string&
62122
62123   return jresult;
62124 }
62125
62126
62127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62128   void * jresult ;
62129   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62130   std::string *arg2 = 0 ;
62131   Dali::PathConstrainer 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)->GetPathConstrainer((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::PathConstrainer((const Dali::PathConstrainer &)result);
62163
62164   //argout typemap for const std::string&
62165
62166   return jresult;
62167 }
62168
62169
62170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62171   void * jresult ;
62172   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62173   std::string *arg2 = 0 ;
62174   Dali::LinearConstrainer result;
62175
62176   arg1 = (Dali::Toolkit::Builder *)jarg1;
62177   if (!jarg2) {
62178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62179     return 0;
62180   }
62181   std::string arg2_str(jarg2);
62182   arg2 = &arg2_str;
62183   {
62184     try {
62185       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62186     } catch (std::out_of_range& e) {
62187       {
62188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62189       };
62190     } catch (std::exception& e) {
62191       {
62192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62193       };
62194     } catch (Dali::DaliException e) {
62195       {
62196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62197       };
62198     } catch (...) {
62199       {
62200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62201       };
62202     }
62203   }
62204
62205   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62206
62207   //argout typemap for const std::string&
62208
62209   return jresult;
62210 }
62211
62212
62213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62214   void * jresult ;
62215   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62216   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62217
62218   arg1 = (Dali::Toolkit::Builder *)jarg1;
62219   {
62220     try {
62221       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62222     } catch (std::out_of_range& e) {
62223       {
62224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62225       };
62226     } catch (std::exception& e) {
62227       {
62228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62229       };
62230     } catch (Dali::DaliException e) {
62231       {
62232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62233       };
62234     } catch (...) {
62235       {
62236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62237       };
62238     }
62239   }
62240
62241   jresult = (void *)result;
62242   return jresult;
62243 }
62244
62245
62246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62247   void * jresult ;
62248   Dali::Toolkit::TransitionData *result = 0 ;
62249
62250   {
62251     try {
62252       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62253     } catch (std::out_of_range& e) {
62254       {
62255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62256       };
62257     } catch (std::exception& e) {
62258       {
62259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62260       };
62261     } catch (Dali::DaliException e) {
62262       {
62263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62264       };
62265     } catch (...) {
62266       {
62267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62268       };
62269     }
62270   }
62271
62272   jresult = (void *)result;
62273   return jresult;
62274 }
62275
62276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62277   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62278
62279   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62280   {
62281     try {
62282       delete arg1;
62283     } catch (std::out_of_range& e) {
62284       {
62285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62286       };
62287     } catch (std::exception& e) {
62288       {
62289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62290       };
62291     } catch (Dali::DaliException e) {
62292       {
62293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62294       };
62295     } catch (...) {
62296       {
62297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62298       };
62299     }
62300   }
62301
62302 }
62303
62304
62305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62306   void * jresult ;
62307   Dali::Property::Map *arg1 = 0 ;
62308   Dali::Toolkit::TransitionData result;
62309
62310   arg1 = (Dali::Property::Map *)jarg1;
62311   if (!arg1) {
62312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62313     return 0;
62314   }
62315   {
62316     try {
62317       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62318     } catch (std::out_of_range& e) {
62319       {
62320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (std::exception& e) {
62323       {
62324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62325       };
62326     } catch (Dali::DaliException e) {
62327       {
62328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62329       };
62330     } catch (...) {
62331       {
62332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62333       };
62334     }
62335   }
62336
62337   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62338   return jresult;
62339 }
62340
62341
62342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62343   void * jresult ;
62344   Dali::Property::Array *arg1 = 0 ;
62345   Dali::Toolkit::TransitionData result;
62346
62347   arg1 = (Dali::Property::Array *)jarg1;
62348   if (!arg1) {
62349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62350     return 0;
62351   }
62352   {
62353     try {
62354       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62355     } catch (std::out_of_range& e) {
62356       {
62357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62358       };
62359     } catch (std::exception& e) {
62360       {
62361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62362       };
62363     } catch (Dali::DaliException e) {
62364       {
62365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62366       };
62367     } catch (...) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62370       };
62371     }
62372   }
62373
62374   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62375   return jresult;
62376 }
62377
62378
62379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62380   void * jresult ;
62381   Dali::BaseHandle arg1 ;
62382   Dali::BaseHandle *argp1 ;
62383   Dali::Toolkit::TransitionData result;
62384
62385   argp1 = (Dali::BaseHandle *)jarg1;
62386   if (!argp1) {
62387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62388     return 0;
62389   }
62390   arg1 = *argp1;
62391   {
62392     try {
62393       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62394     } catch (std::out_of_range& e) {
62395       {
62396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62397       };
62398     } catch (std::exception& e) {
62399       {
62400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62401       };
62402     } catch (Dali::DaliException e) {
62403       {
62404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62405       };
62406     } catch (...) {
62407       {
62408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62409       };
62410     }
62411   }
62412
62413   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62414   return jresult;
62415 }
62416
62417
62418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62419   void * jresult ;
62420   Dali::Toolkit::TransitionData *arg1 = 0 ;
62421   Dali::Toolkit::TransitionData *result = 0 ;
62422
62423   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62424   if (!arg1) {
62425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62426     return 0;
62427   }
62428   {
62429     try {
62430       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62431     } catch (std::out_of_range& e) {
62432       {
62433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62434       };
62435     } catch (std::exception& e) {
62436       {
62437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62438       };
62439     } catch (Dali::DaliException e) {
62440       {
62441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62442       };
62443     } catch (...) {
62444       {
62445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62446       };
62447     }
62448   }
62449
62450   jresult = (void *)result;
62451   return jresult;
62452 }
62453
62454
62455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62456   void * jresult ;
62457   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62458   Dali::Toolkit::TransitionData *arg2 = 0 ;
62459   Dali::Toolkit::TransitionData *result = 0 ;
62460
62461   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62462   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62463   if (!arg2) {
62464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62465     return 0;
62466   }
62467   {
62468     try {
62469       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62470     } catch (std::out_of_range& e) {
62471       {
62472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62473       };
62474     } catch (std::exception& e) {
62475       {
62476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62477       };
62478     } catch (Dali::DaliException e) {
62479       {
62480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62481       };
62482     } catch (...) {
62483       {
62484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62485       };
62486     }
62487   }
62488
62489   jresult = (void *)result;
62490   return jresult;
62491 }
62492
62493
62494 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62495   unsigned long jresult ;
62496   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62497   size_t result;
62498
62499   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62500   {
62501     try {
62502       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62503     } catch (std::out_of_range& e) {
62504       {
62505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62506       };
62507     } catch (std::exception& e) {
62508       {
62509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62510       };
62511     } catch (Dali::DaliException e) {
62512       {
62513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62514       };
62515     } catch (...) {
62516       {
62517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62518       };
62519     }
62520   }
62521
62522   jresult = (unsigned long)result;
62523   return jresult;
62524 }
62525
62526
62527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62528   void * jresult ;
62529   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62530   size_t arg2 ;
62531   Dali::Property::Map result;
62532
62533   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62534   arg2 = (size_t)jarg2;
62535   {
62536     try {
62537       result = (arg1)->GetAnimatorAt(arg2);
62538     } catch (std::out_of_range& e) {
62539       {
62540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62541       };
62542     } catch (std::exception& e) {
62543       {
62544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62545       };
62546     } catch (Dali::DaliException e) {
62547       {
62548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62549       };
62550     } catch (...) {
62551       {
62552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62553       };
62554     }
62555   }
62556
62557   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62558   return jresult;
62559 }
62560
62561
62562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62563   int jresult ;
62564   int result;
62565
62566   {
62567     try {
62568       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62569     } catch (std::out_of_range& e) {
62570       {
62571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62572       };
62573     } catch (std::exception& e) {
62574       {
62575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62576       };
62577     } catch (Dali::DaliException e) {
62578       {
62579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62580       };
62581     } catch (...) {
62582       {
62583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62584       };
62585     }
62586   }
62587
62588   jresult = (int)result;
62589   return jresult;
62590 }
62591
62592
62593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62594   int jresult ;
62595   int result;
62596
62597   {
62598     try {
62599       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62600     } catch (std::out_of_range& e) {
62601       {
62602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62603       };
62604     } catch (std::exception& e) {
62605       {
62606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62607       };
62608     } catch (Dali::DaliException e) {
62609       {
62610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62611       };
62612     } catch (...) {
62613       {
62614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62615       };
62616     }
62617   }
62618
62619   jresult = (int)result;
62620   return jresult;
62621 }
62622
62623
62624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62625   int jresult ;
62626   int result;
62627
62628   {
62629     try {
62630       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62631     } catch (std::out_of_range& e) {
62632       {
62633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62634       };
62635     } catch (std::exception& e) {
62636       {
62637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62638       };
62639     } catch (Dali::DaliException e) {
62640       {
62641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62642       };
62643     } catch (...) {
62644       {
62645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62646       };
62647     }
62648   }
62649
62650   jresult = (int)result;
62651   return jresult;
62652 }
62653
62654
62655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62656   int jresult ;
62657   int result;
62658
62659   {
62660     try {
62661       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62662     } catch (std::out_of_range& e) {
62663       {
62664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62665       };
62666     } catch (std::exception& e) {
62667       {
62668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62669       };
62670     } catch (Dali::DaliException e) {
62671       {
62672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62673       };
62674     } catch (...) {
62675       {
62676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62677       };
62678     }
62679   }
62680
62681   jresult = (int)result;
62682   return jresult;
62683 }
62684
62685
62686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62687   int jresult ;
62688   int result;
62689
62690   {
62691     try {
62692       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62693     } catch (std::out_of_range& e) {
62694       {
62695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62696       };
62697     } catch (std::exception& e) {
62698       {
62699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62700       };
62701     } catch (Dali::DaliException e) {
62702       {
62703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62704       };
62705     } catch (...) {
62706       {
62707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62708       };
62709     }
62710   }
62711
62712   jresult = (int)result;
62713   return jresult;
62714 }
62715
62716
62717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62718   int jresult ;
62719   int result;
62720
62721   {
62722     try {
62723       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62724     } catch (std::out_of_range& e) {
62725       {
62726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62727       };
62728     } catch (std::exception& e) {
62729       {
62730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62731       };
62732     } catch (Dali::DaliException e) {
62733       {
62734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62735       };
62736     } catch (...) {
62737       {
62738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62739       };
62740     }
62741   }
62742
62743   jresult = (int)result;
62744   return jresult;
62745 }
62746
62747
62748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62749   int jresult ;
62750   int result;
62751
62752   {
62753     try {
62754       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62755     } catch (std::out_of_range& e) {
62756       {
62757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62758       };
62759     } catch (std::exception& e) {
62760       {
62761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62762       };
62763     } catch (Dali::DaliException e) {
62764       {
62765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62766       };
62767     } catch (...) {
62768       {
62769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62770       };
62771     }
62772   }
62773
62774   jresult = (int)result;
62775   return jresult;
62776 }
62777
62778
62779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62780   int jresult ;
62781   int result;
62782
62783   {
62784     try {
62785       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62786     } catch (std::out_of_range& e) {
62787       {
62788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62789       };
62790     } catch (std::exception& e) {
62791       {
62792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62793       };
62794     } catch (Dali::DaliException e) {
62795       {
62796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62797       };
62798     } catch (...) {
62799       {
62800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62801       };
62802     }
62803   }
62804
62805   jresult = (int)result;
62806   return jresult;
62807 }
62808
62809
62810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62811   int jresult ;
62812   int result;
62813
62814   {
62815     try {
62816       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62817     } catch (std::out_of_range& e) {
62818       {
62819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62820       };
62821     } catch (std::exception& e) {
62822       {
62823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62824       };
62825     } catch (Dali::DaliException e) {
62826       {
62827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62828       };
62829     } catch (...) {
62830       {
62831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62832       };
62833     }
62834   }
62835
62836   jresult = (int)result;
62837   return jresult;
62838 }
62839
62840
62841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62842   int jresult ;
62843   int result;
62844
62845   {
62846     try {
62847       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62848     } catch (std::out_of_range& e) {
62849       {
62850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62851       };
62852     } catch (std::exception& e) {
62853       {
62854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62855       };
62856     } catch (Dali::DaliException e) {
62857       {
62858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62859       };
62860     } catch (...) {
62861       {
62862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62863       };
62864     }
62865   }
62866
62867   jresult = (int)result;
62868   return jresult;
62869 }
62870
62871
62872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62873   int jresult ;
62874   int result;
62875
62876   {
62877     try {
62878       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62879     } catch (std::out_of_range& e) {
62880       {
62881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62882       };
62883     } catch (std::exception& e) {
62884       {
62885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62886       };
62887     } catch (Dali::DaliException e) {
62888       {
62889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62890       };
62891     } catch (...) {
62892       {
62893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62894       };
62895     }
62896   }
62897
62898   jresult = (int)result;
62899   return jresult;
62900 }
62901
62902
62903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62904   int jresult ;
62905   int result;
62906
62907   {
62908     try {
62909       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62910     } catch (std::out_of_range& e) {
62911       {
62912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62913       };
62914     } catch (std::exception& e) {
62915       {
62916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62917       };
62918     } catch (Dali::DaliException e) {
62919       {
62920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62921       };
62922     } catch (...) {
62923       {
62924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62925       };
62926     }
62927   }
62928
62929   jresult = (int)result;
62930   return jresult;
62931 }
62932
62933
62934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62935   int jresult ;
62936   int result;
62937
62938   {
62939     try {
62940       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62941     } catch (std::out_of_range& e) {
62942       {
62943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62944       };
62945     } catch (std::exception& e) {
62946       {
62947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62948       };
62949     } catch (Dali::DaliException e) {
62950       {
62951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62952       };
62953     } catch (...) {
62954       {
62955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62956       };
62957     }
62958   }
62959
62960   jresult = (int)result;
62961   return jresult;
62962 }
62963
62964
62965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62966   int jresult ;
62967   int result;
62968
62969   {
62970     try {
62971       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62972     } catch (std::out_of_range& e) {
62973       {
62974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62975       };
62976     } catch (std::exception& e) {
62977       {
62978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62979       };
62980     } catch (Dali::DaliException e) {
62981       {
62982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62983       };
62984     } catch (...) {
62985       {
62986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62987       };
62988     }
62989   }
62990
62991   jresult = (int)result;
62992   return jresult;
62993 }
62994
62995
62996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62997   void * jresult ;
62998   Dali::Toolkit::Control result;
62999
63000   {
63001     try {
63002       result = Dali::Toolkit::Internal::Control::New();
63003     } catch (std::out_of_range& e) {
63004       {
63005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63006       };
63007     } catch (std::exception& e) {
63008       {
63009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63010       };
63011     } catch (Dali::DaliException e) {
63012       {
63013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63014       };
63015     } catch (...) {
63016       {
63017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63018       };
63019     }
63020   }
63021
63022   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63023   return jresult;
63024 }
63025
63026
63027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63029   std::string *arg2 = 0 ;
63030
63031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63032   if (!jarg2) {
63033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63034     return ;
63035   }
63036   std::string arg2_str(jarg2);
63037   arg2 = &arg2_str;
63038   {
63039     try {
63040       (arg1)->SetStyleName((std::string const &)*arg2);
63041     } catch (std::out_of_range& e) {
63042       {
63043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63044       };
63045     } catch (std::exception& e) {
63046       {
63047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63048       };
63049     } catch (Dali::DaliException e) {
63050       {
63051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63052       };
63053     } catch (...) {
63054       {
63055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63056       };
63057     }
63058   }
63059
63060
63061   //argout typemap for const std::string&
63062
63063 }
63064
63065
63066 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63067   char * jresult ;
63068   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63069   std::string *result = 0 ;
63070
63071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63072   {
63073     try {
63074       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63075     } catch (std::out_of_range& e) {
63076       {
63077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63078       };
63079     } catch (std::exception& e) {
63080       {
63081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63082       };
63083     } catch (Dali::DaliException e) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63086       };
63087     } catch (...) {
63088       {
63089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63090       };
63091     }
63092   }
63093
63094   jresult = SWIG_csharp_string_callback(result->c_str());
63095   return jresult;
63096 }
63097
63098
63099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63101   Dali::Vector4 *arg2 = 0 ;
63102
63103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63104   arg2 = (Dali::Vector4 *)jarg2;
63105   if (!arg2) {
63106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63107     return ;
63108   }
63109   {
63110     try {
63111       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63112     } catch (std::out_of_range& e) {
63113       {
63114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63115       };
63116     } catch (std::exception& e) {
63117       {
63118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63119       };
63120     } catch (Dali::DaliException e) {
63121       {
63122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63123       };
63124     } catch (...) {
63125       {
63126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63127       };
63128     }
63129   }
63130
63131 }
63132
63133
63134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63135   void * jresult ;
63136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63137   Dali::Vector4 result;
63138
63139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63140   {
63141     try {
63142       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63143     } catch (std::out_of_range& e) {
63144       {
63145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63146       };
63147     } catch (std::exception& e) {
63148       {
63149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63150       };
63151     } catch (Dali::DaliException e) {
63152       {
63153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63154       };
63155     } catch (...) {
63156       {
63157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63158       };
63159     }
63160   }
63161
63162   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63163   return jresult;
63164 }
63165
63166
63167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63169   Dali::Image arg2 ;
63170   Dali::Image *argp2 ;
63171
63172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63173   argp2 = (Dali::Image *)jarg2;
63174   if (!argp2) {
63175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63176     return ;
63177   }
63178   arg2 = *argp2;
63179   {
63180     try {
63181       (arg1)->SetBackgroundImage(arg2);
63182     } catch (std::out_of_range& e) {
63183       {
63184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63185       };
63186     } catch (std::exception& e) {
63187       {
63188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63189       };
63190     } catch (Dali::DaliException e) {
63191       {
63192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63193       };
63194     } catch (...) {
63195       {
63196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63197       };
63198     }
63199   }
63200
63201 }
63202
63203
63204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63206   Dali::Property::Map *arg2 = 0 ;
63207
63208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63209   arg2 = (Dali::Property::Map *)jarg2;
63210   if (!arg2) {
63211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63212     return ;
63213   }
63214   {
63215     try {
63216       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63217     } catch (std::out_of_range& e) {
63218       {
63219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63220       };
63221     } catch (std::exception& e) {
63222       {
63223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63224       };
63225     } catch (Dali::DaliException e) {
63226       {
63227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63228       };
63229     } catch (...) {
63230       {
63231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63232       };
63233     }
63234   }
63235
63236 }
63237
63238
63239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63241
63242   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63243   {
63244     try {
63245       (arg1)->ClearBackground();
63246     } catch (std::out_of_range& e) {
63247       {
63248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63249       };
63250     } catch (std::exception& e) {
63251       {
63252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63253       };
63254     } catch (Dali::DaliException e) {
63255       {
63256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63257       };
63258     } catch (...) {
63259       {
63260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63261       };
63262     }
63263   }
63264
63265 }
63266
63267
63268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63270   Dali::Gesture::Type arg2 ;
63271
63272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63273   arg2 = (Dali::Gesture::Type)jarg2;
63274   {
63275     try {
63276       (arg1)->EnableGestureDetection(arg2);
63277     } catch (std::out_of_range& e) {
63278       {
63279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63280       };
63281     } catch (std::exception& e) {
63282       {
63283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63284       };
63285     } catch (Dali::DaliException e) {
63286       {
63287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63288       };
63289     } catch (...) {
63290       {
63291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63292       };
63293     }
63294   }
63295
63296 }
63297
63298
63299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63300   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63301   Dali::Gesture::Type arg2 ;
63302
63303   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63304   arg2 = (Dali::Gesture::Type)jarg2;
63305   {
63306     try {
63307       (arg1)->DisableGestureDetection(arg2);
63308     } catch (std::out_of_range& e) {
63309       {
63310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63311       };
63312     } catch (std::exception& e) {
63313       {
63314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63315       };
63316     } catch (Dali::DaliException e) {
63317       {
63318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63319       };
63320     } catch (...) {
63321       {
63322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63323       };
63324     }
63325   }
63326
63327 }
63328
63329
63330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63331   void * jresult ;
63332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63333   Dali::PinchGestureDetector result;
63334
63335   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63336   {
63337     try {
63338       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63339     } catch (std::out_of_range& e) {
63340       {
63341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63342       };
63343     } catch (std::exception& e) {
63344       {
63345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63346       };
63347     } catch (Dali::DaliException e) {
63348       {
63349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63350       };
63351     } catch (...) {
63352       {
63353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63354       };
63355     }
63356   }
63357
63358   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63359   return jresult;
63360 }
63361
63362
63363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63364   void * jresult ;
63365   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63366   Dali::PanGestureDetector result;
63367
63368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63369   {
63370     try {
63371       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63372     } catch (std::out_of_range& e) {
63373       {
63374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63375       };
63376     } catch (std::exception& e) {
63377       {
63378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63379       };
63380     } catch (Dali::DaliException e) {
63381       {
63382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63383       };
63384     } catch (...) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63387       };
63388     }
63389   }
63390
63391   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63392   return jresult;
63393 }
63394
63395
63396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63397   void * jresult ;
63398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63399   Dali::TapGestureDetector result;
63400
63401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63402   {
63403     try {
63404       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63405     } catch (std::out_of_range& e) {
63406       {
63407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63408       };
63409     } catch (std::exception& e) {
63410       {
63411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63412       };
63413     } catch (Dali::DaliException e) {
63414       {
63415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63416       };
63417     } catch (...) {
63418       {
63419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63420       };
63421     }
63422   }
63423
63424   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63425   return jresult;
63426 }
63427
63428
63429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63430   void * jresult ;
63431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63432   Dali::LongPressGestureDetector result;
63433
63434   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63435   {
63436     try {
63437       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63438     } catch (std::out_of_range& e) {
63439       {
63440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63441       };
63442     } catch (std::exception& e) {
63443       {
63444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63445       };
63446     } catch (Dali::DaliException e) {
63447       {
63448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63449       };
63450     } catch (...) {
63451       {
63452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63453       };
63454     }
63455   }
63456
63457   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63458   return jresult;
63459 }
63460
63461
63462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63464   bool arg2 ;
63465
63466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63467   arg2 = jarg2 ? true : false;
63468   {
63469     try {
63470       (arg1)->SetKeyboardNavigationSupport(arg2);
63471     } catch (std::out_of_range& e) {
63472       {
63473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63474       };
63475     } catch (std::exception& e) {
63476       {
63477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63478       };
63479     } catch (Dali::DaliException e) {
63480       {
63481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63482       };
63483     } catch (...) {
63484       {
63485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63486       };
63487     }
63488   }
63489
63490 }
63491
63492
63493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63494   unsigned int jresult ;
63495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63496   bool result;
63497
63498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63499   {
63500     try {
63501       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63502     } catch (std::out_of_range& e) {
63503       {
63504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63505       };
63506     } catch (std::exception& e) {
63507       {
63508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63509       };
63510     } catch (Dali::DaliException e) {
63511       {
63512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63513       };
63514     } catch (...) {
63515       {
63516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63517       };
63518     }
63519   }
63520
63521   jresult = result;
63522   return jresult;
63523 }
63524
63525
63526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63527   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63528
63529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63530   {
63531     try {
63532       (arg1)->SetKeyInputFocus();
63533     } catch (std::out_of_range& e) {
63534       {
63535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63536       };
63537     } catch (std::exception& e) {
63538       {
63539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63540       };
63541     } catch (Dali::DaliException e) {
63542       {
63543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63544       };
63545     } catch (...) {
63546       {
63547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63548       };
63549     }
63550   }
63551
63552 }
63553
63554
63555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63556   unsigned int jresult ;
63557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63558   bool result;
63559
63560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63561   {
63562     try {
63563       result = (bool)(arg1)->HasKeyInputFocus();
63564     } catch (std::out_of_range& e) {
63565       {
63566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63567       };
63568     } catch (std::exception& e) {
63569       {
63570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63571       };
63572     } catch (Dali::DaliException e) {
63573       {
63574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63575       };
63576     } catch (...) {
63577       {
63578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63579       };
63580     }
63581   }
63582
63583   jresult = result;
63584   return jresult;
63585 }
63586
63587
63588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63590
63591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63592   {
63593     try {
63594       (arg1)->ClearKeyInputFocus();
63595     } catch (std::out_of_range& e) {
63596       {
63597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63598       };
63599     } catch (std::exception& e) {
63600       {
63601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63602       };
63603     } catch (Dali::DaliException e) {
63604       {
63605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63606       };
63607     } catch (...) {
63608       {
63609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63610       };
63611     }
63612   }
63613
63614 }
63615
63616
63617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63618   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63619   bool arg2 ;
63620
63621   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63622   arg2 = jarg2 ? true : false;
63623   {
63624     try {
63625       (arg1)->SetAsKeyboardFocusGroup(arg2);
63626     } catch (std::out_of_range& e) {
63627       {
63628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63629       };
63630     } catch (std::exception& e) {
63631       {
63632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63633       };
63634     } catch (Dali::DaliException e) {
63635       {
63636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63637       };
63638     } catch (...) {
63639       {
63640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63641       };
63642     }
63643   }
63644
63645 }
63646
63647
63648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63649   unsigned int jresult ;
63650   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63651   bool result;
63652
63653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63654   {
63655     try {
63656       result = (bool)(arg1)->IsKeyboardFocusGroup();
63657     } catch (std::out_of_range& e) {
63658       {
63659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63660       };
63661     } catch (std::exception& e) {
63662       {
63663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63664       };
63665     } catch (Dali::DaliException e) {
63666       {
63667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63668       };
63669     } catch (...) {
63670       {
63671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63672       };
63673     }
63674   }
63675
63676   jresult = result;
63677   return jresult;
63678 }
63679
63680
63681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63682   void * jresult ;
63683   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63684   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63685
63686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63687   {
63688     try {
63689       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63690     } catch (std::out_of_range& e) {
63691       {
63692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63693       };
63694     } catch (std::exception& e) {
63695       {
63696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63697       };
63698     } catch (Dali::DaliException e) {
63699       {
63700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63701       };
63702     } catch (...) {
63703       {
63704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63705       };
63706     }
63707   }
63708
63709   jresult = (void *)result;
63710   return jresult;
63711 }
63712
63713
63714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63715   void * jresult ;
63716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63717   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63718
63719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63720   {
63721     try {
63722       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63723     } catch (std::out_of_range& e) {
63724       {
63725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63726       };
63727     } catch (std::exception& e) {
63728       {
63729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63730       };
63731     } catch (Dali::DaliException e) {
63732       {
63733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63734       };
63735     } catch (...) {
63736       {
63737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63738       };
63739     }
63740   }
63741
63742   jresult = (void *)result;
63743   return jresult;
63744 }
63745
63746
63747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63748   void * jresult ;
63749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63750   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63751
63752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63753   {
63754     try {
63755       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63756     } catch (std::out_of_range& e) {
63757       {
63758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63759       };
63760     } catch (std::exception& e) {
63761       {
63762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63763       };
63764     } catch (Dali::DaliException e) {
63765       {
63766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63767       };
63768     } catch (...) {
63769       {
63770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63771       };
63772     }
63773   }
63774
63775   jresult = (void *)result;
63776   return jresult;
63777 }
63778
63779
63780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63782   int arg2 ;
63783   SwigDirector_ViewImpl *darg = 0;
63784
63785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63786   arg2 = (int)jarg2;
63787   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63788   if(!darg) {
63789     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63790     return;
63791   }
63792   {
63793     try {
63794       if(darg) {
63795         (darg)->OnStageConnection(arg2);
63796       }
63797     } catch (std::out_of_range& e) {
63798       {
63799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63800       };
63801     } catch (std::exception& e) {
63802       {
63803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63804       };
63805     } catch (Dali::DaliException e) {
63806       {
63807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63808       };
63809     } catch (...) {
63810       {
63811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63812       };
63813     }
63814   }
63815
63816 }
63817
63818
63819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63821   int arg2 ;
63822   SwigDirector_ViewImpl *darg = 0;
63823
63824   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63825   arg2 = (int)jarg2;
63826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63827   if(!darg) {
63828     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63829     return;
63830   }
63831   {
63832     try {
63833       if(darg) {
63834         (darg)->OnStageConnectionSwigPublic(arg2);
63835       }
63836     } catch (std::out_of_range& e) {
63837       {
63838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63839       };
63840     } catch (std::exception& e) {
63841       {
63842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63843       };
63844     } catch (Dali::DaliException e) {
63845       {
63846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63847       };
63848     } catch (...) {
63849       {
63850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63851       };
63852     }
63853   }
63854
63855 }
63856
63857
63858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63860   SwigDirector_ViewImpl *darg = 0;
63861
63862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63863   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63864   if(!darg) {
63865     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63866     return;
63867   }
63868   {
63869     try {
63870       if(darg) {
63871         (darg)->OnStageDisconnection();
63872       }
63873     } catch (std::out_of_range& e) {
63874       {
63875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63876       };
63877     } catch (std::exception& e) {
63878       {
63879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63880       };
63881     } catch (Dali::DaliException e) {
63882       {
63883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63884       };
63885     } catch (...) {
63886       {
63887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63888       };
63889     }
63890   }
63891
63892 }
63893
63894
63895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63897   SwigDirector_ViewImpl *darg = 0;
63898
63899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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)->OnStageDisconnectionSwigPublic();
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_OnChildAdd(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)->OnChildAdd(*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_OnChildAddSwigExplicitViewImpl(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)->OnChildAddSwigPublic(*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_OnChildRemove(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)->OnChildRemove(*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_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64063   Dali::Actor *arg2 = 0 ;
64064   SwigDirector_ViewImpl *darg = 0;
64065
64066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64067   arg2 = (Dali::Actor *)jarg2;
64068   if (!arg2) {
64069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64070     return ;
64071   }
64072   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64073   if(!darg) {
64074     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64075     return;
64076   }
64077   {
64078     try {
64079       if(darg) {
64080         (darg)->OnChildRemoveSwigPublic(*arg2);
64081       }
64082     } catch (std::out_of_range& e) {
64083       {
64084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64085       };
64086     } catch (std::exception& e) {
64087       {
64088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64089       };
64090     } catch (Dali::DaliException e) {
64091       {
64092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64093       };
64094     } catch (...) {
64095       {
64096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64097       };
64098     }
64099   }
64100
64101 }
64102
64103
64104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64106   Dali::Property::Index arg2 ;
64107   Dali::Property::Value arg3 ;
64108   Dali::Property::Value *argp3 ;
64109   SwigDirector_ViewImpl *darg = 0;
64110
64111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64112   arg2 = (Dali::Property::Index)jarg2;
64113   argp3 = (Dali::Property::Value *)jarg3;
64114   if (!argp3) {
64115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64116     return ;
64117   }
64118   arg3 = *argp3;
64119   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64120   if (!darg) {
64121     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64122     return;
64123   }
64124   {
64125     try {
64126       (darg)->OnPropertySet(arg2,arg3);
64127     } catch (std::out_of_range& e) {
64128       {
64129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64130       };
64131     } catch (std::exception& e) {
64132       {
64133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64134       };
64135     } catch (Dali::DaliException e) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64138       };
64139     } catch (...) {
64140       {
64141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64142       };
64143     }
64144   }
64145
64146 }
64147
64148
64149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64151   Dali::Property::Index arg2 ;
64152   Dali::Property::Value arg3 ;
64153   Dali::Property::Value *argp3 ;
64154   SwigDirector_ViewImpl *darg = 0;
64155
64156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64157   arg2 = (Dali::Property::Index)jarg2;
64158   argp3 = (Dali::Property::Value *)jarg3;
64159   if (!argp3) {
64160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64161     return ;
64162   }
64163   arg3 = *argp3;
64164   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64165   if (!darg) {
64166     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64167     return;
64168   }
64169   {
64170     try {
64171       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64172     } catch (std::out_of_range& e) {
64173       {
64174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64175       };
64176     } catch (std::exception& e) {
64177       {
64178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64179       };
64180     } catch (Dali::DaliException e) {
64181       {
64182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64183       };
64184     } catch (...) {
64185       {
64186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64187       };
64188     }
64189   }
64190
64191 }
64192
64193
64194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64196   Dali::Vector3 *arg2 = 0 ;
64197   SwigDirector_ViewImpl *darg = 0;
64198
64199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64200   arg2 = (Dali::Vector3 *)jarg2;
64201   if (!arg2) {
64202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64203     return ;
64204   }
64205   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64206   if (!darg) {
64207     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64208     return;
64209   }
64210   {
64211     try {
64212       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64213     } catch (std::out_of_range& e) {
64214       {
64215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64216       };
64217     } catch (std::exception& e) {
64218       {
64219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64220       };
64221     } catch (Dali::DaliException e) {
64222       {
64223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64224       };
64225     } catch (...) {
64226       {
64227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64228       };
64229     }
64230   }
64231
64232 }
64233
64234
64235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64237   Dali::Vector3 *arg2 = 0 ;
64238   SwigDirector_ViewImpl *darg = 0;
64239
64240   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64241   arg2 = (Dali::Vector3 *)jarg2;
64242   if (!arg2) {
64243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64244     return ;
64245   }
64246   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64247   if (!darg) {
64248     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64249     return;
64250   }
64251   {
64252     try {
64253       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64254     } catch (std::out_of_range& e) {
64255       {
64256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64257       };
64258     } catch (std::exception& e) {
64259       {
64260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64261       };
64262     } catch (Dali::DaliException e) {
64263       {
64264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64265       };
64266     } catch (...) {
64267       {
64268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64269       };
64270     }
64271   }
64272
64273 }
64274
64275
64276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64277   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64278   Dali::Animation *arg2 = 0 ;
64279   Dali::Vector3 *arg3 = 0 ;
64280   SwigDirector_ViewImpl *darg = 0;
64281
64282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64283   arg2 = (Dali::Animation *)jarg2;
64284   if (!arg2) {
64285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64286     return ;
64287   }
64288   arg3 = (Dali::Vector3 *)jarg3;
64289   if (!arg3) {
64290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64291     return ;
64292   }
64293   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64294   if (!darg) {
64295     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64296     return;
64297   }
64298   {
64299     try {
64300       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64301     } catch (std::out_of_range& e) {
64302       {
64303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64304       };
64305     } catch (std::exception& e) {
64306       {
64307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64308       };
64309     } catch (Dali::DaliException e) {
64310       {
64311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64312       };
64313     } catch (...) {
64314       {
64315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64316       };
64317     }
64318   }
64319
64320 }
64321
64322
64323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64325   Dali::Animation *arg2 = 0 ;
64326   Dali::Vector3 *arg3 = 0 ;
64327   SwigDirector_ViewImpl *darg = 0;
64328
64329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64330   arg2 = (Dali::Animation *)jarg2;
64331   if (!arg2) {
64332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64333     return ;
64334   }
64335   arg3 = (Dali::Vector3 *)jarg3;
64336   if (!arg3) {
64337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64338     return ;
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;
64344   }
64345   {
64346     try {
64347       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64348     } catch (std::out_of_range& e) {
64349       {
64350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64351       };
64352     } catch (std::exception& e) {
64353       {
64354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64355       };
64356     } catch (Dali::DaliException e) {
64357       {
64358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64359       };
64360     } catch (...) {
64361       {
64362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64363       };
64364     }
64365   }
64366
64367 }
64368
64369
64370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64371   unsigned int jresult ;
64372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64373   Dali::TouchEvent *arg2 = 0 ;
64374   SwigDirector_ViewImpl *darg = 0;
64375   bool result;
64376
64377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64378   arg2 = (Dali::TouchEvent *)jarg2;
64379   if (!arg2) {
64380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64381     return 0;
64382   }
64383   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64384   if (!darg) {
64385     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64386     return 0;
64387   }
64388   {
64389     try {
64390       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64391     } catch (std::out_of_range& e) {
64392       {
64393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64394       };
64395     } catch (std::exception& e) {
64396       {
64397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64398       };
64399     } catch (Dali::DaliException e) {
64400       {
64401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64402       };
64403     } catch (...) {
64404       {
64405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64406       };
64407     }
64408   }
64409
64410   jresult = result;
64411   return jresult;
64412 }
64413
64414
64415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64416   unsigned int jresult ;
64417   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64418   Dali::TouchEvent *arg2 = 0 ;
64419   SwigDirector_ViewImpl *darg = 0;
64420   bool result;
64421
64422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64423   arg2 = (Dali::TouchEvent *)jarg2;
64424   if (!arg2) {
64425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64426     return 0;
64427   }
64428   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64429   if (!darg) {
64430     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64431     return 0;
64432   }
64433   {
64434     try {
64435       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64436     } catch (std::out_of_range& e) {
64437       {
64438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64439       };
64440     } catch (std::exception& e) {
64441       {
64442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64443       };
64444     } catch (Dali::DaliException e) {
64445       {
64446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64447       };
64448     } catch (...) {
64449       {
64450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64451       };
64452     }
64453   }
64454
64455   jresult = result;
64456   return jresult;
64457 }
64458
64459
64460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64461   unsigned int jresult ;
64462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64463   Dali::HoverEvent *arg2 = 0 ;
64464   SwigDirector_ViewImpl *darg = 0;
64465   bool result;
64466
64467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64468   arg2 = (Dali::HoverEvent *)jarg2;
64469   if (!arg2) {
64470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64471     return 0;
64472   }
64473   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64474   if (!darg) {
64475     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64476     return 0;
64477   }
64478   {
64479     try {
64480       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64481     } catch (std::out_of_range& e) {
64482       {
64483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64484       };
64485     } catch (std::exception& e) {
64486       {
64487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64488       };
64489     } catch (Dali::DaliException e) {
64490       {
64491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64492       };
64493     } catch (...) {
64494       {
64495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64496       };
64497     }
64498   }
64499
64500   jresult = result;
64501   return jresult;
64502 }
64503
64504
64505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64506   unsigned int jresult ;
64507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64508   Dali::HoverEvent *arg2 = 0 ;
64509   SwigDirector_ViewImpl *darg = 0;
64510   bool result;
64511
64512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64513   arg2 = (Dali::HoverEvent *)jarg2;
64514   if (!arg2) {
64515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64516     return 0;
64517   }
64518   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64519   if (!darg) {
64520     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64521     return 0;
64522   }
64523   {
64524     try {
64525       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64526     } catch (std::out_of_range& e) {
64527       {
64528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64529       };
64530     } catch (std::exception& e) {
64531       {
64532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64533       };
64534     } catch (Dali::DaliException e) {
64535       {
64536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64537       };
64538     } catch (...) {
64539       {
64540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64541       };
64542     }
64543   }
64544
64545   jresult = result;
64546   return jresult;
64547 }
64548
64549
64550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64551   unsigned int jresult ;
64552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64553   Dali::KeyEvent *arg2 = 0 ;
64554   SwigDirector_ViewImpl *darg = 0;
64555   bool result;
64556
64557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64558   arg2 = (Dali::KeyEvent *)jarg2;
64559   if (!arg2) {
64560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64561     return 0;
64562   }
64563   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64564   if (!darg) {
64565     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64566     return 0;
64567   }
64568   {
64569     try {
64570       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64571     } catch (std::out_of_range& e) {
64572       {
64573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64574       };
64575     } catch (std::exception& e) {
64576       {
64577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64578       };
64579     } catch (Dali::DaliException e) {
64580       {
64581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64582       };
64583     } catch (...) {
64584       {
64585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64586       };
64587     }
64588   }
64589
64590   jresult = result;
64591   return jresult;
64592 }
64593
64594
64595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64596   unsigned int jresult ;
64597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64598   Dali::KeyEvent *arg2 = 0 ;
64599   SwigDirector_ViewImpl *darg = 0;
64600   bool result;
64601
64602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64603   arg2 = (Dali::KeyEvent *)jarg2;
64604   if (!arg2) {
64605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64606     return 0;
64607   }
64608   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64609   if (!darg) {
64610     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64611     return 0;
64612   }
64613   {
64614     try {
64615       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64616     } catch (std::out_of_range& e) {
64617       {
64618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64619       };
64620     } catch (std::exception& e) {
64621       {
64622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64623       };
64624     } catch (Dali::DaliException e) {
64625       {
64626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64627       };
64628     } catch (...) {
64629       {
64630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64631       };
64632     }
64633   }
64634
64635   jresult = result;
64636   return jresult;
64637 }
64638
64639
64640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64641   unsigned int jresult ;
64642   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64643   Dali::WheelEvent *arg2 = 0 ;
64644   SwigDirector_ViewImpl *darg = 0;
64645   bool result;
64646
64647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64648   arg2 = (Dali::WheelEvent *)jarg2;
64649   if (!arg2) {
64650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64651     return 0;
64652   }
64653   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64654   if (!darg) {
64655     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64656     return 0;
64657   }
64658   {
64659     try {
64660       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64661     } catch (std::out_of_range& e) {
64662       {
64663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64664       };
64665     } catch (std::exception& e) {
64666       {
64667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64668       };
64669     } catch (Dali::DaliException e) {
64670       {
64671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64672       };
64673     } catch (...) {
64674       {
64675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64676       };
64677     }
64678   }
64679
64680   jresult = result;
64681   return jresult;
64682 }
64683
64684
64685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64686   unsigned int jresult ;
64687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64688   Dali::WheelEvent *arg2 = 0 ;
64689   SwigDirector_ViewImpl *darg = 0;
64690   bool result;
64691
64692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64693   arg2 = (Dali::WheelEvent *)jarg2;
64694   if (!arg2) {
64695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64696     return 0;
64697   }
64698   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64699   if (!darg) {
64700     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64701     return 0;
64702   }
64703   {
64704     try {
64705       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64706     } catch (std::out_of_range& e) {
64707       {
64708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64709       };
64710     } catch (std::exception& e) {
64711       {
64712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64713       };
64714     } catch (Dali::DaliException e) {
64715       {
64716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64717       };
64718     } catch (...) {
64719       {
64720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64721       };
64722     }
64723   }
64724
64725   jresult = result;
64726   return jresult;
64727 }
64728
64729
64730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64731   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64732   Dali::Vector2 *arg2 = 0 ;
64733   Dali::RelayoutContainer *arg3 = 0 ;
64734   SwigDirector_ViewImpl *darg = 0;
64735
64736   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64737   arg2 = (Dali::Vector2 *)jarg2;
64738   if (!arg2) {
64739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64740     return ;
64741   }
64742   arg3 = (Dali::RelayoutContainer *)jarg3;
64743   if (!arg3) {
64744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64745     return ;
64746   }
64747   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64748   if (!darg) {
64749     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64750     return;
64751   }
64752   {
64753     try {
64754       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64755     } catch (std::out_of_range& e) {
64756       {
64757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64758       };
64759     } catch (std::exception& e) {
64760       {
64761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64762       };
64763     } catch (Dali::DaliException e) {
64764       {
64765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64766       };
64767     } catch (...) {
64768       {
64769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64770       };
64771     }
64772   }
64773
64774 }
64775
64776
64777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64779   Dali::Vector2 *arg2 = 0 ;
64780   Dali::RelayoutContainer *arg3 = 0 ;
64781   SwigDirector_ViewImpl *darg = 0;
64782
64783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64784   arg2 = (Dali::Vector2 *)jarg2;
64785   if (!arg2) {
64786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64787     return ;
64788   }
64789   arg3 = (Dali::RelayoutContainer *)jarg3;
64790   if (!arg3) {
64791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64792     return ;
64793   }
64794   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64795   if (!darg) {
64796     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64797     return;
64798   }
64799   {
64800     try {
64801       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64802     } catch (std::out_of_range& e) {
64803       {
64804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64805       };
64806     } catch (std::exception& e) {
64807       {
64808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64809       };
64810     } catch (Dali::DaliException e) {
64811       {
64812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64813       };
64814     } catch (...) {
64815       {
64816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64817       };
64818     }
64819   }
64820
64821 }
64822
64823
64824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64826   Dali::ResizePolicy::Type arg2 ;
64827   Dali::Dimension::Type arg3 ;
64828   SwigDirector_ViewImpl *darg = 0;
64829
64830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64831   arg2 = (Dali::ResizePolicy::Type)jarg2;
64832   arg3 = (Dali::Dimension::Type)jarg3;
64833   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64834   if (!darg) {
64835     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64836     return;
64837   }
64838   {
64839     try {
64840       (darg)->OnSetResizePolicy(arg2,arg3);
64841     } catch (std::out_of_range& e) {
64842       {
64843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64844       };
64845     } catch (std::exception& e) {
64846       {
64847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64848       };
64849     } catch (Dali::DaliException e) {
64850       {
64851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64852       };
64853     } catch (...) {
64854       {
64855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64856       };
64857     }
64858   }
64859
64860 }
64861
64862
64863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64865   Dali::ResizePolicy::Type arg2 ;
64866   Dali::Dimension::Type arg3 ;
64867   SwigDirector_ViewImpl *darg = 0;
64868
64869   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64870   arg2 = (Dali::ResizePolicy::Type)jarg2;
64871   arg3 = (Dali::Dimension::Type)jarg3;
64872   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64873   if (!darg) {
64874     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64875     return;
64876   }
64877   {
64878     try {
64879       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64880     } catch (std::out_of_range& e) {
64881       {
64882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64883       };
64884     } catch (std::exception& e) {
64885       {
64886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64887       };
64888     } catch (Dali::DaliException e) {
64889       {
64890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64891       };
64892     } catch (...) {
64893       {
64894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64895       };
64896     }
64897   }
64898
64899 }
64900
64901
64902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64903   void * jresult ;
64904   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64905   SwigDirector_ViewImpl *darg = 0;
64906   Dali::Vector3 result;
64907
64908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64909   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64910   if (!darg) {
64911     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64912     return 0;
64913   }
64914   {
64915     try {
64916       result = (darg)->GetNaturalSize();
64917     } catch (std::out_of_range& e) {
64918       {
64919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64920       };
64921     } catch (std::exception& e) {
64922       {
64923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64924       };
64925     } catch (Dali::DaliException e) {
64926       {
64927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64928       };
64929     } catch (...) {
64930       {
64931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64932       };
64933     }
64934   }
64935
64936   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64937   return jresult;
64938 }
64939
64940
64941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64942   void * jresult ;
64943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64944   SwigDirector_ViewImpl *darg = 0;
64945   Dali::Vector3 result;
64946
64947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64948   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64949   if (!darg) {
64950     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64951     return 0;
64952   }
64953   {
64954     try {
64955       result = (darg)->GetNaturalSizeSwigPublic();
64956     } catch (std::out_of_range& e) {
64957       {
64958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64959       };
64960     } catch (std::exception& e) {
64961       {
64962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64963       };
64964     } catch (Dali::DaliException e) {
64965       {
64966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64967       };
64968     } catch (...) {
64969       {
64970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64971       };
64972     }
64973   }
64974
64975   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64976   return jresult;
64977 }
64978
64979
64980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64981   float jresult ;
64982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64983   Dali::Actor *arg2 = 0 ;
64984   Dali::Dimension::Type arg3 ;
64985   SwigDirector_ViewImpl *darg = 0;
64986   float result;
64987
64988   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64989   arg2 = (Dali::Actor *)jarg2;
64990   if (!arg2) {
64991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64992     return 0;
64993   }
64994   arg3 = (Dali::Dimension::Type)jarg3;
64995   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64996   if (!darg) {
64997     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64998     return 0;
64999   }
65000   {
65001     try {
65002       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65003     } catch (std::out_of_range& e) {
65004       {
65005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65006       };
65007     } catch (std::exception& e) {
65008       {
65009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65010       };
65011     } catch (Dali::DaliException e) {
65012       {
65013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65014       };
65015     } catch (...) {
65016       {
65017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65018       };
65019     }
65020   }
65021
65022   jresult = result;
65023   return jresult;
65024 }
65025
65026
65027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65028   float jresult ;
65029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65030   Dali::Actor *arg2 = 0 ;
65031   Dali::Dimension::Type arg3 ;
65032   SwigDirector_ViewImpl *darg = 0;
65033   float result;
65034
65035   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65036   arg2 = (Dali::Actor *)jarg2;
65037   if (!arg2) {
65038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65039     return 0;
65040   }
65041   arg3 = (Dali::Dimension::Type)jarg3;
65042   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65043   if (!darg) {
65044     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65045     return 0;
65046   }
65047   {
65048     try {
65049       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65050     } catch (std::out_of_range& e) {
65051       {
65052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65053       };
65054     } catch (std::exception& e) {
65055       {
65056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65057       };
65058     } catch (Dali::DaliException e) {
65059       {
65060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65061       };
65062     } catch (...) {
65063       {
65064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65065       };
65066     }
65067   }
65068
65069   jresult = result;
65070   return jresult;
65071 }
65072
65073
65074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65075   float jresult ;
65076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65077   float arg2 ;
65078   SwigDirector_ViewImpl *darg = 0;
65079   float result;
65080
65081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65082   arg2 = (float)jarg2;
65083   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65084   if (!darg) {
65085     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65086     return 0;
65087   }
65088   {
65089     try {
65090       result = (float)(darg)->GetHeightForWidth(arg2);
65091     } catch (std::out_of_range& e) {
65092       {
65093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65094       };
65095     } catch (std::exception& e) {
65096       {
65097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65098       };
65099     } catch (Dali::DaliException e) {
65100       {
65101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65102       };
65103     } catch (...) {
65104       {
65105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65106       };
65107     }
65108   }
65109
65110   jresult = result;
65111   return jresult;
65112 }
65113
65114
65115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65116   float jresult ;
65117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65118   float arg2 ;
65119   SwigDirector_ViewImpl *darg = 0;
65120   float result;
65121
65122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65123   arg2 = (float)jarg2;
65124   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65125   if (!darg) {
65126     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65127     return 0;
65128   }
65129   {
65130     try {
65131       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65132     } catch (std::out_of_range& e) {
65133       {
65134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65135       };
65136     } catch (std::exception& e) {
65137       {
65138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65139       };
65140     } catch (Dali::DaliException e) {
65141       {
65142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65143       };
65144     } catch (...) {
65145       {
65146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65147       };
65148     }
65149   }
65150
65151   jresult = result;
65152   return jresult;
65153 }
65154
65155
65156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65157   float jresult ;
65158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65159   float arg2 ;
65160   SwigDirector_ViewImpl *darg = 0;
65161   float result;
65162
65163   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65164   arg2 = (float)jarg2;
65165   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65166   if (!darg) {
65167     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65168     return 0;
65169   }
65170   {
65171     try {
65172       result = (float)(darg)->GetWidthForHeight(arg2);
65173     } catch (std::out_of_range& e) {
65174       {
65175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65176       };
65177     } catch (std::exception& e) {
65178       {
65179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65180       };
65181     } catch (Dali::DaliException e) {
65182       {
65183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65184       };
65185     } catch (...) {
65186       {
65187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65188       };
65189     }
65190   }
65191
65192   jresult = result;
65193   return jresult;
65194 }
65195
65196
65197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65198   float jresult ;
65199   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65200   float arg2 ;
65201   SwigDirector_ViewImpl *darg = 0;
65202   float result;
65203
65204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65205   arg2 = (float)jarg2;
65206   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65207   if (!darg) {
65208     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65209     return 0;
65210   }
65211   {
65212     try {
65213       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65214     } catch (std::out_of_range& e) {
65215       {
65216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65217       };
65218     } catch (std::exception& e) {
65219       {
65220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65221       };
65222     } catch (Dali::DaliException e) {
65223       {
65224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65225       };
65226     } catch (...) {
65227       {
65228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65229       };
65230     }
65231   }
65232
65233   jresult = result;
65234   return jresult;
65235 }
65236
65237
65238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65239   unsigned int jresult ;
65240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65241   Dali::Dimension::Type arg2 ;
65242   SwigDirector_ViewImpl *darg = 0;
65243   bool result;
65244
65245   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65246   arg2 = (Dali::Dimension::Type)jarg2;
65247   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65248   if (!darg) {
65249     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65250     return 0;
65251   }
65252   {
65253     try {
65254       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65255     } catch (std::out_of_range& e) {
65256       {
65257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65258       };
65259     } catch (std::exception& e) {
65260       {
65261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65262       };
65263     } catch (Dali::DaliException e) {
65264       {
65265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65266       };
65267     } catch (...) {
65268       {
65269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65270       };
65271     }
65272   }
65273
65274   jresult = result;
65275   return jresult;
65276 }
65277
65278
65279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65280   unsigned int jresult ;
65281   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65282   Dali::Dimension::Type arg2 ;
65283   SwigDirector_ViewImpl *darg = 0;
65284   bool result;
65285
65286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65287   arg2 = (Dali::Dimension::Type)jarg2;
65288   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65289   if (!darg) {
65290     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65291     return 0;
65292   }
65293   {
65294     try {
65295       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65296     } catch (std::out_of_range& e) {
65297       {
65298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65299       };
65300     } catch (std::exception& e) {
65301       {
65302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65303       };
65304     } catch (Dali::DaliException e) {
65305       {
65306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65307       };
65308     } catch (...) {
65309       {
65310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65311       };
65312     }
65313   }
65314
65315   jresult = result;
65316   return jresult;
65317 }
65318
65319
65320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65321   unsigned int jresult ;
65322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65323   SwigDirector_ViewImpl *darg = 0;
65324   bool result;
65325
65326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65327   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65328   if (!darg) {
65329     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65330     return 0;
65331   }
65332   {
65333     try {
65334       result = (bool)(darg)->RelayoutDependentOnChildren();
65335     } catch (std::out_of_range& e) {
65336       {
65337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65338       };
65339     } catch (std::exception& e) {
65340       {
65341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65342       };
65343     } catch (Dali::DaliException e) {
65344       {
65345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65346       };
65347     } catch (...) {
65348       {
65349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65350       };
65351     }
65352   }
65353
65354   jresult = result;
65355   return jresult;
65356 }
65357
65358
65359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65360   unsigned int jresult ;
65361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65362   SwigDirector_ViewImpl *darg = 0;
65363   bool result;
65364
65365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65366   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65367   if (!darg) {
65368     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65369     return 0;
65370   }
65371   {
65372     try {
65373       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65374     } catch (std::out_of_range& e) {
65375       {
65376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65377       };
65378     } catch (std::exception& e) {
65379       {
65380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65381       };
65382     } catch (Dali::DaliException e) {
65383       {
65384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65385       };
65386     } catch (...) {
65387       {
65388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65389       };
65390     }
65391   }
65392
65393   jresult = result;
65394   return jresult;
65395 }
65396
65397
65398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65400   Dali::Dimension::Type arg2 ;
65401   SwigDirector_ViewImpl *darg = 0;
65402
65403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65404   arg2 = (Dali::Dimension::Type)jarg2;
65405   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65406   if (!darg) {
65407     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65408     return;
65409   }
65410   {
65411     try {
65412       (darg)->OnCalculateRelayoutSize(arg2);
65413     } catch (std::out_of_range& e) {
65414       {
65415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65416       };
65417     } catch (std::exception& e) {
65418       {
65419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65420       };
65421     } catch (Dali::DaliException e) {
65422       {
65423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65424       };
65425     } catch (...) {
65426       {
65427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65428       };
65429     }
65430   }
65431
65432 }
65433
65434
65435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65437   Dali::Dimension::Type arg2 ;
65438   SwigDirector_ViewImpl *darg = 0;
65439
65440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65441   arg2 = (Dali::Dimension::Type)jarg2;
65442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65443   if (!darg) {
65444     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65445     return;
65446   }
65447   {
65448     try {
65449       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65450     } catch (std::out_of_range& e) {
65451       {
65452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65453       };
65454     } catch (std::exception& e) {
65455       {
65456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65457       };
65458     } catch (Dali::DaliException e) {
65459       {
65460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65461       };
65462     } catch (...) {
65463       {
65464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65465       };
65466     }
65467   }
65468
65469 }
65470
65471
65472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65474   float arg2 ;
65475   Dali::Dimension::Type arg3 ;
65476   SwigDirector_ViewImpl *darg = 0;
65477
65478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65479   arg2 = (float)jarg2;
65480   arg3 = (Dali::Dimension::Type)jarg3;
65481   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65482   if (!darg) {
65483     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65484     return;
65485   }
65486   {
65487     try {
65488       (darg)->OnLayoutNegotiated(arg2,arg3);
65489     } catch (std::out_of_range& e) {
65490       {
65491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65492       };
65493     } catch (std::exception& e) {
65494       {
65495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65496       };
65497     } catch (Dali::DaliException e) {
65498       {
65499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65500       };
65501     } catch (...) {
65502       {
65503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65504       };
65505     }
65506   }
65507
65508 }
65509
65510
65511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65513   float arg2 ;
65514   Dali::Dimension::Type arg3 ;
65515   SwigDirector_ViewImpl *darg = 0;
65516
65517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65518   arg2 = (float)jarg2;
65519   arg3 = (Dali::Dimension::Type)jarg3;
65520   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65521   if (!darg) {
65522     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65523     return;
65524   }
65525   {
65526     try {
65527       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65528     } catch (std::out_of_range& e) {
65529       {
65530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65531       };
65532     } catch (std::exception& e) {
65533       {
65534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65535       };
65536     } catch (Dali::DaliException e) {
65537       {
65538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65539       };
65540     } catch (...) {
65541       {
65542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65543       };
65544     }
65545   }
65546
65547 }
65548
65549
65550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65552
65553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65554   {
65555     try {
65556       (arg1)->OnInitialize();
65557     } catch (std::out_of_range& e) {
65558       {
65559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65560       };
65561     } catch (std::exception& e) {
65562       {
65563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65564       };
65565     } catch (Dali::DaliException e) {
65566       {
65567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65568       };
65569     } catch (...) {
65570       {
65571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65572       };
65573     }
65574   }
65575
65576 }
65577
65578
65579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65580   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65581
65582   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65583   {
65584     try {
65585       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65586     } catch (std::out_of_range& e) {
65587       {
65588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65589       };
65590     } catch (std::exception& e) {
65591       {
65592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65593       };
65594     } catch (Dali::DaliException e) {
65595       {
65596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65597       };
65598     } catch (...) {
65599       {
65600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65601       };
65602     }
65603   }
65604
65605 }
65606
65607
65608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65610   Dali::Actor *arg2 = 0 ;
65611
65612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65613   arg2 = (Dali::Actor *)jarg2;
65614   if (!arg2) {
65615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65616     return ;
65617   }
65618   {
65619     try {
65620       (arg1)->OnControlChildAdd(*arg2);
65621     } catch (std::out_of_range& e) {
65622       {
65623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65624       };
65625     } catch (std::exception& e) {
65626       {
65627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65628       };
65629     } catch (Dali::DaliException e) {
65630       {
65631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65632       };
65633     } catch (...) {
65634       {
65635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65636       };
65637     }
65638   }
65639
65640 }
65641
65642
65643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65645   Dali::Actor *arg2 = 0 ;
65646
65647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65648   arg2 = (Dali::Actor *)jarg2;
65649   if (!arg2) {
65650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65651     return ;
65652   }
65653   {
65654     try {
65655       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65656     } catch (std::out_of_range& e) {
65657       {
65658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65659       };
65660     } catch (std::exception& e) {
65661       {
65662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65663       };
65664     } catch (Dali::DaliException e) {
65665       {
65666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65667       };
65668     } catch (...) {
65669       {
65670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65671       };
65672     }
65673   }
65674
65675 }
65676
65677
65678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65680   Dali::Actor *arg2 = 0 ;
65681
65682   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65683   arg2 = (Dali::Actor *)jarg2;
65684   if (!arg2) {
65685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65686     return ;
65687   }
65688   {
65689     try {
65690       (arg1)->OnControlChildRemove(*arg2);
65691     } catch (std::out_of_range& e) {
65692       {
65693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65694       };
65695     } catch (std::exception& e) {
65696       {
65697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65698       };
65699     } catch (Dali::DaliException e) {
65700       {
65701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65702       };
65703     } catch (...) {
65704       {
65705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65706       };
65707     }
65708   }
65709
65710 }
65711
65712
65713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65715   Dali::Actor *arg2 = 0 ;
65716
65717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65718   arg2 = (Dali::Actor *)jarg2;
65719   if (!arg2) {
65720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65721     return ;
65722   }
65723   {
65724     try {
65725       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65726     } catch (std::out_of_range& e) {
65727       {
65728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65729       };
65730     } catch (std::exception& e) {
65731       {
65732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65733       };
65734     } catch (Dali::DaliException e) {
65735       {
65736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65737       };
65738     } catch (...) {
65739       {
65740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65741       };
65742     }
65743   }
65744
65745 }
65746
65747
65748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65750   Dali::Toolkit::StyleManager arg2 ;
65751   Dali::StyleChange::Type arg3 ;
65752   Dali::Toolkit::StyleManager *argp2 ;
65753
65754   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65755   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65756   if (!argp2) {
65757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65758     return ;
65759   }
65760   arg2 = *argp2;
65761   arg3 = (Dali::StyleChange::Type)jarg3;
65762   {
65763     try {
65764       (arg1)->OnStyleChange(arg2,arg3);
65765     } catch (std::out_of_range& e) {
65766       {
65767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65768       };
65769     } catch (std::exception& e) {
65770       {
65771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65772       };
65773     } catch (Dali::DaliException e) {
65774       {
65775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65776       };
65777     } catch (...) {
65778       {
65779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65780       };
65781     }
65782   }
65783
65784 }
65785
65786
65787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65788   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65789   Dali::Toolkit::StyleManager arg2 ;
65790   Dali::StyleChange::Type arg3 ;
65791   Dali::Toolkit::StyleManager *argp2 ;
65792
65793   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65794   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65795   if (!argp2) {
65796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65797     return ;
65798   }
65799   arg2 = *argp2;
65800   arg3 = (Dali::StyleChange::Type)jarg3;
65801   {
65802     try {
65803       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65804     } catch (std::out_of_range& e) {
65805       {
65806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65807       };
65808     } catch (std::exception& e) {
65809       {
65810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65811       };
65812     } catch (Dali::DaliException e) {
65813       {
65814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65815       };
65816     } catch (...) {
65817       {
65818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65819       };
65820     }
65821   }
65822
65823 }
65824
65825
65826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65827   unsigned int jresult ;
65828   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65829   bool result;
65830
65831   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65832   {
65833     try {
65834       result = (bool)(arg1)->OnAccessibilityActivated();
65835     } catch (std::out_of_range& e) {
65836       {
65837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65838       };
65839     } catch (std::exception& e) {
65840       {
65841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65842       };
65843     } catch (Dali::DaliException e) {
65844       {
65845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65846       };
65847     } catch (...) {
65848       {
65849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65850       };
65851     }
65852   }
65853
65854   jresult = result;
65855   return jresult;
65856 }
65857
65858
65859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65860   unsigned int jresult ;
65861   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65862   bool result;
65863
65864   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65865   {
65866     try {
65867       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65868     } catch (std::out_of_range& e) {
65869       {
65870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65871       };
65872     } catch (std::exception& e) {
65873       {
65874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65875       };
65876     } catch (Dali::DaliException e) {
65877       {
65878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65879       };
65880     } catch (...) {
65881       {
65882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65883       };
65884     }
65885   }
65886
65887   jresult = result;
65888   return jresult;
65889 }
65890
65891
65892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65893   unsigned int jresult ;
65894   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65895   Dali::PanGesture arg2 ;
65896   Dali::PanGesture *argp2 ;
65897   bool result;
65898
65899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65900   argp2 = (Dali::PanGesture *)jarg2;
65901   if (!argp2) {
65902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65903     return 0;
65904   }
65905   arg2 = *argp2;
65906   {
65907     try {
65908       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65909     } catch (std::out_of_range& e) {
65910       {
65911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65912       };
65913     } catch (std::exception& e) {
65914       {
65915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65916       };
65917     } catch (Dali::DaliException e) {
65918       {
65919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65920       };
65921     } catch (...) {
65922       {
65923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65924       };
65925     }
65926   }
65927
65928   jresult = result;
65929   return jresult;
65930 }
65931
65932
65933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65934   unsigned int jresult ;
65935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65936   Dali::PanGesture arg2 ;
65937   Dali::PanGesture *argp2 ;
65938   bool result;
65939
65940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65941   argp2 = (Dali::PanGesture *)jarg2;
65942   if (!argp2) {
65943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65944     return 0;
65945   }
65946   arg2 = *argp2;
65947   {
65948     try {
65949       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65950     } catch (std::out_of_range& e) {
65951       {
65952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65953       };
65954     } catch (std::exception& e) {
65955       {
65956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65957       };
65958     } catch (Dali::DaliException e) {
65959       {
65960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65961       };
65962     } catch (...) {
65963       {
65964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65965       };
65966     }
65967   }
65968
65969   jresult = result;
65970   return jresult;
65971 }
65972
65973
65974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65975   unsigned int jresult ;
65976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65977   Dali::TouchEvent *arg2 = 0 ;
65978   bool result;
65979
65980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65981   arg2 = (Dali::TouchEvent *)jarg2;
65982   if (!arg2) {
65983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65984     return 0;
65985   }
65986   {
65987     try {
65988       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65989     } catch (std::out_of_range& e) {
65990       {
65991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65992       };
65993     } catch (std::exception& e) {
65994       {
65995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65996       };
65997     } catch (Dali::DaliException e) {
65998       {
65999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66000       };
66001     } catch (...) {
66002       {
66003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66004       };
66005     }
66006   }
66007
66008   jresult = result;
66009   return jresult;
66010 }
66011
66012
66013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66014   unsigned int jresult ;
66015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66016   Dali::TouchEvent *arg2 = 0 ;
66017   bool result;
66018
66019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66020   arg2 = (Dali::TouchEvent *)jarg2;
66021   if (!arg2) {
66022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66023     return 0;
66024   }
66025   {
66026     try {
66027       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66028     } catch (std::out_of_range& e) {
66029       {
66030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66031       };
66032     } catch (std::exception& e) {
66033       {
66034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66035       };
66036     } catch (Dali::DaliException e) {
66037       {
66038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66039       };
66040     } catch (...) {
66041       {
66042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66043       };
66044     }
66045   }
66046
66047   jresult = result;
66048   return jresult;
66049 }
66050
66051
66052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66053   unsigned int jresult ;
66054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66055   bool arg2 ;
66056   bool result;
66057
66058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66059   arg2 = jarg2 ? true : false;
66060   {
66061     try {
66062       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66063     } catch (std::out_of_range& e) {
66064       {
66065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66066       };
66067     } catch (std::exception& e) {
66068       {
66069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66070       };
66071     } catch (Dali::DaliException e) {
66072       {
66073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66074       };
66075     } catch (...) {
66076       {
66077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66078       };
66079     }
66080   }
66081
66082   jresult = result;
66083   return jresult;
66084 }
66085
66086
66087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66088   unsigned int jresult ;
66089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66090   bool arg2 ;
66091   bool result;
66092
66093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66094   arg2 = jarg2 ? true : false;
66095   {
66096     try {
66097       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66098     } catch (std::out_of_range& e) {
66099       {
66100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66101       };
66102     } catch (std::exception& e) {
66103       {
66104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66105       };
66106     } catch (Dali::DaliException e) {
66107       {
66108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66109       };
66110     } catch (...) {
66111       {
66112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66113       };
66114     }
66115   }
66116
66117   jresult = result;
66118   return jresult;
66119 }
66120
66121
66122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66123   unsigned int jresult ;
66124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66125   bool result;
66126
66127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66128   {
66129     try {
66130       result = (bool)(arg1)->OnAccessibilityZoom();
66131     } catch (std::out_of_range& e) {
66132       {
66133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66134       };
66135     } catch (std::exception& e) {
66136       {
66137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66138       };
66139     } catch (Dali::DaliException e) {
66140       {
66141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66142       };
66143     } catch (...) {
66144       {
66145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66146       };
66147     }
66148   }
66149
66150   jresult = result;
66151   return jresult;
66152 }
66153
66154
66155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66156   unsigned int jresult ;
66157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66158   bool result;
66159
66160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66161   {
66162     try {
66163       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66164     } catch (std::out_of_range& e) {
66165       {
66166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66167       };
66168     } catch (std::exception& e) {
66169       {
66170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66171       };
66172     } catch (Dali::DaliException e) {
66173       {
66174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66175       };
66176     } catch (...) {
66177       {
66178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66179       };
66180     }
66181   }
66182
66183   jresult = result;
66184   return jresult;
66185 }
66186
66187
66188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66189   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66190
66191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66192   {
66193     try {
66194       (arg1)->OnKeyInputFocusGained();
66195     } catch (std::out_of_range& e) {
66196       {
66197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66198       };
66199     } catch (std::exception& e) {
66200       {
66201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66202       };
66203     } catch (Dali::DaliException e) {
66204       {
66205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66206       };
66207     } catch (...) {
66208       {
66209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66210       };
66211     }
66212   }
66213
66214 }
66215
66216
66217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66219
66220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66221   {
66222     try {
66223       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66224     } catch (std::out_of_range& e) {
66225       {
66226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66227       };
66228     } catch (std::exception& e) {
66229       {
66230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66231       };
66232     } catch (Dali::DaliException e) {
66233       {
66234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66235       };
66236     } catch (...) {
66237       {
66238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66239       };
66240     }
66241   }
66242
66243 }
66244
66245
66246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66248
66249   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66250   {
66251     try {
66252       (arg1)->OnKeyInputFocusLost();
66253     } catch (std::out_of_range& e) {
66254       {
66255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66256       };
66257     } catch (std::exception& e) {
66258       {
66259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66260       };
66261     } catch (Dali::DaliException e) {
66262       {
66263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66264       };
66265     } catch (...) {
66266       {
66267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66268       };
66269     }
66270   }
66271
66272 }
66273
66274
66275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66277
66278   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66279   {
66280     try {
66281       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66282     } catch (std::out_of_range& e) {
66283       {
66284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66285       };
66286     } catch (std::exception& e) {
66287       {
66288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66289       };
66290     } catch (Dali::DaliException e) {
66291       {
66292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66293       };
66294     } catch (...) {
66295       {
66296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66297       };
66298     }
66299   }
66300
66301 }
66302
66303
66304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66305   void * jresult ;
66306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66307   Dali::Actor arg2 ;
66308   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66309   bool arg4 ;
66310   Dali::Actor *argp2 ;
66311   Dali::Actor result;
66312
66313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66314   argp2 = (Dali::Actor *)jarg2;
66315   if (!argp2) {
66316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66317     return 0;
66318   }
66319   arg2 = *argp2;
66320   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66321   arg4 = jarg4 ? true : false;
66322   {
66323     try {
66324       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66325     } catch (std::out_of_range& e) {
66326       {
66327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66328       };
66329     } catch (std::exception& e) {
66330       {
66331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66332       };
66333     } catch (Dali::DaliException e) {
66334       {
66335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66336       };
66337     } catch (...) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66340       };
66341     }
66342   }
66343
66344   jresult = new Dali::Actor((const Dali::Actor &)result);
66345   return jresult;
66346 }
66347
66348
66349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66350   void * jresult ;
66351   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66352   Dali::Actor arg2 ;
66353   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66354   bool arg4 ;
66355   Dali::Actor *argp2 ;
66356   Dali::Actor result;
66357
66358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66359   argp2 = (Dali::Actor *)jarg2;
66360   if (!argp2) {
66361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66362     return 0;
66363   }
66364   arg2 = *argp2;
66365   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66366   arg4 = jarg4 ? true : false;
66367   {
66368     try {
66369       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66370     } catch (std::out_of_range& e) {
66371       {
66372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66373       };
66374     } catch (std::exception& e) {
66375       {
66376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66377       };
66378     } catch (Dali::DaliException e) {
66379       {
66380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66381       };
66382     } catch (...) {
66383       {
66384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66385       };
66386     }
66387   }
66388
66389   jresult = new Dali::Actor((const Dali::Actor &)result);
66390   return jresult;
66391 }
66392
66393
66394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66396   Dali::Actor arg2 ;
66397   Dali::Actor *argp2 ;
66398
66399   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66400   argp2 = (Dali::Actor *)jarg2;
66401   if (!argp2) {
66402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66403     return ;
66404   }
66405   arg2 = *argp2;
66406   {
66407     try {
66408       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66409     } catch (std::out_of_range& e) {
66410       {
66411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66412       };
66413     } catch (std::exception& e) {
66414       {
66415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66416       };
66417     } catch (Dali::DaliException e) {
66418       {
66419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66420       };
66421     } catch (...) {
66422       {
66423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66424       };
66425     }
66426   }
66427
66428 }
66429
66430
66431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66432   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66433   Dali::Actor arg2 ;
66434   Dali::Actor *argp2 ;
66435
66436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66437   argp2 = (Dali::Actor *)jarg2;
66438   if (!argp2) {
66439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66440     return ;
66441   }
66442   arg2 = *argp2;
66443   {
66444     try {
66445       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66446     } catch (std::out_of_range& e) {
66447       {
66448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66449       };
66450     } catch (std::exception& e) {
66451       {
66452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66453       };
66454     } catch (Dali::DaliException e) {
66455       {
66456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66457       };
66458     } catch (...) {
66459       {
66460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66461       };
66462     }
66463   }
66464
66465 }
66466
66467
66468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66469   unsigned int jresult ;
66470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66471   bool result;
66472
66473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66474   {
66475     try {
66476       result = (bool)(arg1)->OnKeyboardEnter();
66477     } catch (std::out_of_range& e) {
66478       {
66479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66480       };
66481     } catch (std::exception& e) {
66482       {
66483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66484       };
66485     } catch (Dali::DaliException e) {
66486       {
66487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66488       };
66489     } catch (...) {
66490       {
66491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66492       };
66493     }
66494   }
66495
66496   jresult = result;
66497   return jresult;
66498 }
66499
66500
66501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66502   unsigned int jresult ;
66503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66504   bool result;
66505
66506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66507   {
66508     try {
66509       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66510     } catch (std::out_of_range& e) {
66511       {
66512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66513       };
66514     } catch (std::exception& e) {
66515       {
66516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66517       };
66518     } catch (Dali::DaliException e) {
66519       {
66520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66521       };
66522     } catch (...) {
66523       {
66524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66525       };
66526     }
66527   }
66528
66529   jresult = result;
66530   return jresult;
66531 }
66532
66533
66534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66536   Dali::PinchGesture *arg2 = 0 ;
66537
66538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66539   arg2 = (Dali::PinchGesture *)jarg2;
66540   if (!arg2) {
66541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66542     return ;
66543   }
66544   {
66545     try {
66546       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66547     } catch (std::out_of_range& e) {
66548       {
66549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66550       };
66551     } catch (std::exception& e) {
66552       {
66553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66554       };
66555     } catch (Dali::DaliException e) {
66556       {
66557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66558       };
66559     } catch (...) {
66560       {
66561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66562       };
66563     }
66564   }
66565
66566 }
66567
66568
66569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66571   Dali::PinchGesture *arg2 = 0 ;
66572
66573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66574   arg2 = (Dali::PinchGesture *)jarg2;
66575   if (!arg2) {
66576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66577     return ;
66578   }
66579   {
66580     try {
66581       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66582     } catch (std::out_of_range& e) {
66583       {
66584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66585       };
66586     } catch (std::exception& e) {
66587       {
66588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66589       };
66590     } catch (Dali::DaliException e) {
66591       {
66592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66593       };
66594     } catch (...) {
66595       {
66596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66597       };
66598     }
66599   }
66600
66601 }
66602
66603
66604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66606   Dali::PanGesture *arg2 = 0 ;
66607
66608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66609   arg2 = (Dali::PanGesture *)jarg2;
66610   if (!arg2) {
66611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66612     return ;
66613   }
66614   {
66615     try {
66616       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66617     } catch (std::out_of_range& e) {
66618       {
66619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66620       };
66621     } catch (std::exception& e) {
66622       {
66623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66624       };
66625     } catch (Dali::DaliException e) {
66626       {
66627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66628       };
66629     } catch (...) {
66630       {
66631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66632       };
66633     }
66634   }
66635
66636 }
66637
66638
66639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66641   Dali::PanGesture *arg2 = 0 ;
66642
66643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66644   arg2 = (Dali::PanGesture *)jarg2;
66645   if (!arg2) {
66646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66647     return ;
66648   }
66649   {
66650     try {
66651       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66652     } catch (std::out_of_range& e) {
66653       {
66654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66655       };
66656     } catch (std::exception& e) {
66657       {
66658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66659       };
66660     } catch (Dali::DaliException e) {
66661       {
66662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66663       };
66664     } catch (...) {
66665       {
66666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66667       };
66668     }
66669   }
66670
66671 }
66672
66673
66674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66676   Dali::TapGesture *arg2 = 0 ;
66677
66678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66679   arg2 = (Dali::TapGesture *)jarg2;
66680   if (!arg2) {
66681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66682     return ;
66683   }
66684   {
66685     try {
66686       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66687     } catch (std::out_of_range& e) {
66688       {
66689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66690       };
66691     } catch (std::exception& e) {
66692       {
66693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66694       };
66695     } catch (Dali::DaliException e) {
66696       {
66697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66698       };
66699     } catch (...) {
66700       {
66701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66702       };
66703     }
66704   }
66705
66706 }
66707
66708
66709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66711   Dali::TapGesture *arg2 = 0 ;
66712
66713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66714   arg2 = (Dali::TapGesture *)jarg2;
66715   if (!arg2) {
66716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66717     return ;
66718   }
66719   {
66720     try {
66721       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66722     } catch (std::out_of_range& e) {
66723       {
66724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66725       };
66726     } catch (std::exception& e) {
66727       {
66728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66729       };
66730     } catch (Dali::DaliException e) {
66731       {
66732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66733       };
66734     } catch (...) {
66735       {
66736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66737       };
66738     }
66739   }
66740
66741 }
66742
66743
66744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66746   Dali::LongPressGesture *arg2 = 0 ;
66747
66748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66749   arg2 = (Dali::LongPressGesture *)jarg2;
66750   if (!arg2) {
66751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66752     return ;
66753   }
66754   {
66755     try {
66756       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66757     } catch (std::out_of_range& e) {
66758       {
66759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66760       };
66761     } catch (std::exception& e) {
66762       {
66763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66764       };
66765     } catch (Dali::DaliException e) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66768       };
66769     } catch (...) {
66770       {
66771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66772       };
66773     }
66774   }
66775
66776 }
66777
66778
66779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66781   Dali::LongPressGesture *arg2 = 0 ;
66782
66783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66784   arg2 = (Dali::LongPressGesture *)jarg2;
66785   if (!arg2) {
66786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66787     return ;
66788   }
66789   {
66790     try {
66791       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66792     } catch (std::out_of_range& e) {
66793       {
66794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66795       };
66796     } catch (std::exception& e) {
66797       {
66798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66799       };
66800     } catch (Dali::DaliException e) {
66801       {
66802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66803       };
66804     } catch (...) {
66805       {
66806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66807       };
66808     }
66809   }
66810
66811 }
66812
66813
66814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66816   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66817   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66818
66819   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66820   arg2 = (Dali::SlotObserver *)jarg2;
66821   arg3 = (Dali::CallbackBase *)jarg3;
66822   {
66823     try {
66824       (arg1)->SignalConnected(arg2,arg3);
66825     } catch (std::out_of_range& e) {
66826       {
66827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66828       };
66829     } catch (std::exception& e) {
66830       {
66831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66832       };
66833     } catch (Dali::DaliException e) {
66834       {
66835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66836       };
66837     } catch (...) {
66838       {
66839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66840       };
66841     }
66842   }
66843
66844 }
66845
66846
66847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66849   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66850   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66851
66852   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66853   arg2 = (Dali::SlotObserver *)jarg2;
66854   arg3 = (Dali::CallbackBase *)jarg3;
66855   {
66856     try {
66857       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66858     } catch (std::out_of_range& e) {
66859       {
66860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66861       };
66862     } catch (std::exception& e) {
66863       {
66864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66865       };
66866     } catch (Dali::DaliException e) {
66867       {
66868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66869       };
66870     } catch (...) {
66871       {
66872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66873       };
66874     }
66875   }
66876
66877 }
66878
66879
66880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66882   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66883   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66884
66885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66886   arg2 = (Dali::SlotObserver *)jarg2;
66887   arg3 = (Dali::CallbackBase *)jarg3;
66888   {
66889     try {
66890       (arg1)->SignalDisconnected(arg2,arg3);
66891     } catch (std::out_of_range& e) {
66892       {
66893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66894       };
66895     } catch (std::exception& e) {
66896       {
66897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66898       };
66899     } catch (Dali::DaliException e) {
66900       {
66901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66902       };
66903     } catch (...) {
66904       {
66905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66906       };
66907     }
66908   }
66909
66910 }
66911
66912
66913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66915   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66916   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66917
66918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66919   arg2 = (Dali::SlotObserver *)jarg2;
66920   arg3 = (Dali::CallbackBase *)jarg3;
66921   {
66922     try {
66923       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66924     } catch (std::out_of_range& e) {
66925       {
66926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66927       };
66928     } catch (std::exception& e) {
66929       {
66930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66931       };
66932     } catch (Dali::DaliException e) {
66933       {
66934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66935       };
66936     } catch (...) {
66937       {
66938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66939       };
66940     }
66941   }
66942
66943 }
66944
66945
66946 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) {
66947   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66948   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66949   if (director) {
66950     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);
66951   }
66952 }
66953
66954
66955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66956   void * jresult ;
66957   Dali::Toolkit::Control *arg1 = 0 ;
66958   Dali::Toolkit::Internal::Control *result = 0 ;
66959
66960   arg1 = (Dali::Toolkit::Control *)jarg1;
66961   if (!arg1) {
66962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66963     return 0;
66964   }
66965   {
66966     try {
66967       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66968     } catch (std::out_of_range& e) {
66969       {
66970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66971       };
66972     } catch (std::exception& e) {
66973       {
66974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66975       };
66976     } catch (Dali::DaliException e) {
66977       {
66978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66979       };
66980     } catch (...) {
66981       {
66982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66983       };
66984     }
66985   }
66986
66987   jresult = (void *)result;
66988   return jresult;
66989 }
66990
66991
66992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66993   int jresult ;
66994   int result;
66995
66996   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66997   jresult = (int)result;
66998   return jresult;
66999 }
67000
67001
67002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67003   int jresult ;
67004   int result;
67005
67006   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67007   jresult = (int)result;
67008   return jresult;
67009 }
67010
67011
67012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67013   int jresult ;
67014   int result;
67015
67016   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67017   jresult = (int)result;
67018   return jresult;
67019 }
67020
67021
67022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67023   int jresult ;
67024   int result;
67025
67026   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67027   jresult = (int)result;
67028   return jresult;
67029 }
67030
67031
67032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67033   int jresult ;
67034   int result;
67035
67036   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67037   jresult = (int)result;
67038   return jresult;
67039 }
67040
67041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67042   int jresult ;
67043   int result;
67044
67045   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67046   jresult = (int)result;
67047   return jresult;
67048 }
67049
67050
67051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67052   int jresult ;
67053   int result;
67054
67055   result = (int)Dali::Toolkit::Control::Property::PADDING;
67056   jresult = (int)result;
67057   return jresult;
67058 }
67059
67060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67061   void * jresult ;
67062   Dali::Toolkit::Control::Property *result = 0 ;
67063
67064   {
67065     try {
67066       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67067     } catch (std::out_of_range& e) {
67068       {
67069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67070       };
67071     } catch (std::exception& e) {
67072       {
67073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67074       };
67075     } catch (Dali::DaliException e) {
67076       {
67077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67078       };
67079     } catch (...) {
67080       {
67081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67082       };
67083     }
67084   }
67085
67086   jresult = (void *)result;
67087   return jresult;
67088 }
67089
67090
67091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67092   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67093
67094   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67095   {
67096     try {
67097       delete arg1;
67098     } catch (std::out_of_range& e) {
67099       {
67100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67101       };
67102     } catch (std::exception& e) {
67103       {
67104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67105       };
67106     } catch (Dali::DaliException e) {
67107       {
67108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67109       };
67110     } catch (...) {
67111       {
67112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67113       };
67114     }
67115   }
67116
67117 }
67118
67119
67120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67121   void * jresult ;
67122   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67123
67124   {
67125     try {
67126       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67127     } catch (std::out_of_range& e) {
67128       {
67129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67130       };
67131     } catch (std::exception& e) {
67132       {
67133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67134       };
67135     } catch (Dali::DaliException e) {
67136       {
67137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67138       };
67139     } catch (...) {
67140       {
67141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67142       };
67143     }
67144   }
67145
67146   jresult = (void *)result;
67147   return jresult;
67148 }
67149
67150
67151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67152   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67153
67154   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67155   {
67156     try {
67157       delete arg1;
67158     } catch (std::out_of_range& e) {
67159       {
67160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67161       };
67162     } catch (std::exception& e) {
67163       {
67164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67165       };
67166     } catch (Dali::DaliException e) {
67167       {
67168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67169       };
67170     } catch (...) {
67171       {
67172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67173       };
67174     }
67175   }
67176
67177 }
67178
67179
67180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67181   void * jresult ;
67182   Dali::Toolkit::Control result;
67183
67184   {
67185     try {
67186       result = Dali::Toolkit::Control::New();
67187     } catch (std::out_of_range& e) {
67188       {
67189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67190       };
67191     } catch (std::exception& e) {
67192       {
67193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67194       };
67195     } catch (Dali::DaliException e) {
67196       {
67197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67198       };
67199     } catch (...) {
67200       {
67201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67202       };
67203     }
67204   }
67205
67206   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67207   return jresult;
67208 }
67209
67210
67211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67212   void * jresult ;
67213   Dali::Toolkit::Control *result = 0 ;
67214
67215   {
67216     try {
67217       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67218     } catch (std::out_of_range& e) {
67219       {
67220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67221       };
67222     } catch (std::exception& e) {
67223       {
67224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67225       };
67226     } catch (Dali::DaliException e) {
67227       {
67228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67229       };
67230     } catch (...) {
67231       {
67232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67233       };
67234     }
67235   }
67236
67237   jresult = (void *)result;
67238   return jresult;
67239 }
67240
67241
67242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67243   void * jresult ;
67244   Dali::Toolkit::Control *arg1 = 0 ;
67245   Dali::Toolkit::Control *result = 0 ;
67246
67247   arg1 = (Dali::Toolkit::Control *)jarg1;
67248   if (!arg1) {
67249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67250     return 0;
67251   }
67252   {
67253     try {
67254       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67255     } catch (std::out_of_range& e) {
67256       {
67257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67258       };
67259     } catch (std::exception& e) {
67260       {
67261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67262       };
67263     } catch (Dali::DaliException e) {
67264       {
67265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67266       };
67267     } catch (...) {
67268       {
67269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67270       };
67271     }
67272   }
67273
67274   jresult = (void *)result;
67275   return jresult;
67276 }
67277
67278
67279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67280   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67281
67282   arg1 = (Dali::Toolkit::Control *)jarg1;
67283   {
67284     try {
67285       delete arg1;
67286     } catch (std::out_of_range& e) {
67287       {
67288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67289       };
67290     } catch (std::exception& e) {
67291       {
67292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67293       };
67294     } catch (Dali::DaliException e) {
67295       {
67296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67297       };
67298     } catch (...) {
67299       {
67300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67301       };
67302     }
67303   }
67304
67305 }
67306
67307
67308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67309   void * jresult ;
67310   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67311   Dali::Toolkit::Control *arg2 = 0 ;
67312   Dali::Toolkit::Control *result = 0 ;
67313
67314   arg1 = (Dali::Toolkit::Control *)jarg1;
67315   arg2 = (Dali::Toolkit::Control *)jarg2;
67316   if (!arg2) {
67317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67318     return 0;
67319   }
67320   {
67321     try {
67322       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67323     } catch (std::out_of_range& e) {
67324       {
67325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67326       };
67327     } catch (std::exception& e) {
67328       {
67329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67330       };
67331     } catch (Dali::DaliException e) {
67332       {
67333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67334       };
67335     } catch (...) {
67336       {
67337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67338       };
67339     }
67340   }
67341
67342   jresult = (void *)result;
67343   return jresult;
67344 }
67345
67346
67347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67348   void * jresult ;
67349   Dali::BaseHandle arg1 ;
67350   Dali::BaseHandle *argp1 ;
67351   Dali::Toolkit::Control result;
67352
67353   argp1 = (Dali::BaseHandle *)jarg1;
67354   if (!argp1) {
67355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67356     return 0;
67357   }
67358   arg1 = *argp1;
67359   {
67360     try {
67361       result = Dali::Toolkit::Control::DownCast(arg1);
67362     } catch (std::out_of_range& e) {
67363       {
67364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67365       };
67366     } catch (std::exception& e) {
67367       {
67368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67369       };
67370     } catch (Dali::DaliException e) {
67371       {
67372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67373       };
67374     } catch (...) {
67375       {
67376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67377       };
67378     }
67379   }
67380
67381   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67382   return jresult;
67383 }
67384
67385
67386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67387   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67388
67389   arg1 = (Dali::Toolkit::Control *)jarg1;
67390   {
67391     try {
67392       (arg1)->SetKeyInputFocus();
67393     } catch (std::out_of_range& e) {
67394       {
67395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67396       };
67397     } catch (std::exception& e) {
67398       {
67399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67400       };
67401     } catch (Dali::DaliException e) {
67402       {
67403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67404       };
67405     } catch (...) {
67406       {
67407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67408       };
67409     }
67410   }
67411
67412 }
67413
67414
67415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67416   unsigned int jresult ;
67417   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67418   bool result;
67419
67420   arg1 = (Dali::Toolkit::Control *)jarg1;
67421   {
67422     try {
67423       result = (bool)(arg1)->HasKeyInputFocus();
67424     } catch (std::out_of_range& e) {
67425       {
67426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67427       };
67428     } catch (std::exception& e) {
67429       {
67430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67431       };
67432     } catch (Dali::DaliException e) {
67433       {
67434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67435       };
67436     } catch (...) {
67437       {
67438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67439       };
67440     }
67441   }
67442
67443   jresult = result;
67444   return jresult;
67445 }
67446
67447
67448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67449   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67450
67451   arg1 = (Dali::Toolkit::Control *)jarg1;
67452   {
67453     try {
67454       (arg1)->ClearKeyInputFocus();
67455     } catch (std::out_of_range& e) {
67456       {
67457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67458       };
67459     } catch (std::exception& e) {
67460       {
67461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67462       };
67463     } catch (Dali::DaliException e) {
67464       {
67465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67466       };
67467     } catch (...) {
67468       {
67469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67470       };
67471     }
67472   }
67473
67474 }
67475
67476
67477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67478   void * jresult ;
67479   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67480   Dali::PinchGestureDetector result;
67481
67482   arg1 = (Dali::Toolkit::Control *)jarg1;
67483   {
67484     try {
67485       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67486     } catch (std::out_of_range& e) {
67487       {
67488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67489       };
67490     } catch (std::exception& e) {
67491       {
67492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67493       };
67494     } catch (Dali::DaliException e) {
67495       {
67496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67497       };
67498     } catch (...) {
67499       {
67500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67501       };
67502     }
67503   }
67504
67505   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67506   return jresult;
67507 }
67508
67509
67510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67511   void * jresult ;
67512   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67513   Dali::PanGestureDetector result;
67514
67515   arg1 = (Dali::Toolkit::Control *)jarg1;
67516   {
67517     try {
67518       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67519     } catch (std::out_of_range& e) {
67520       {
67521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67522       };
67523     } catch (std::exception& e) {
67524       {
67525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67526       };
67527     } catch (Dali::DaliException e) {
67528       {
67529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67530       };
67531     } catch (...) {
67532       {
67533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67534       };
67535     }
67536   }
67537
67538   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67539   return jresult;
67540 }
67541
67542
67543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67544   void * jresult ;
67545   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67546   Dali::TapGestureDetector result;
67547
67548   arg1 = (Dali::Toolkit::Control *)jarg1;
67549   {
67550     try {
67551       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67552     } catch (std::out_of_range& e) {
67553       {
67554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67555       };
67556     } catch (std::exception& e) {
67557       {
67558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67559       };
67560     } catch (Dali::DaliException e) {
67561       {
67562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67563       };
67564     } catch (...) {
67565       {
67566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67567       };
67568     }
67569   }
67570
67571   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67572   return jresult;
67573 }
67574
67575
67576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67577   void * jresult ;
67578   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67579   Dali::LongPressGestureDetector result;
67580
67581   arg1 = (Dali::Toolkit::Control *)jarg1;
67582   {
67583     try {
67584       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67585     } catch (std::out_of_range& e) {
67586       {
67587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67588       };
67589     } catch (std::exception& e) {
67590       {
67591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67592       };
67593     } catch (Dali::DaliException e) {
67594       {
67595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67596       };
67597     } catch (...) {
67598       {
67599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67600       };
67601     }
67602   }
67603
67604   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67605   return jresult;
67606 }
67607
67608
67609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67610   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67611   std::string *arg2 = 0 ;
67612
67613   arg1 = (Dali::Toolkit::Control *)jarg1;
67614   if (!jarg2) {
67615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67616     return ;
67617   }
67618   std::string arg2_str(jarg2);
67619   arg2 = &arg2_str;
67620   {
67621     try {
67622       (arg1)->SetStyleName((std::string const &)*arg2);
67623     } catch (std::out_of_range& e) {
67624       {
67625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67626       };
67627     } catch (std::exception& e) {
67628       {
67629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67630       };
67631     } catch (Dali::DaliException e) {
67632       {
67633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67634       };
67635     } catch (...) {
67636       {
67637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67638       };
67639     }
67640   }
67641
67642
67643   //argout typemap for const std::string&
67644
67645 }
67646
67647
67648 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67649   char * jresult ;
67650   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67651   std::string *result = 0 ;
67652
67653   arg1 = (Dali::Toolkit::Control *)jarg1;
67654   {
67655     try {
67656       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67657     } catch (std::out_of_range& e) {
67658       {
67659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67660       };
67661     } catch (std::exception& e) {
67662       {
67663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67664       };
67665     } catch (Dali::DaliException e) {
67666       {
67667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67668       };
67669     } catch (...) {
67670       {
67671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67672       };
67673     }
67674   }
67675
67676   jresult = SWIG_csharp_string_callback(result->c_str());
67677   return jresult;
67678 }
67679
67680
67681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67682   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67683   Dali::Vector4 *arg2 = 0 ;
67684
67685   arg1 = (Dali::Toolkit::Control *)jarg1;
67686   arg2 = (Dali::Vector4 *)jarg2;
67687   if (!arg2) {
67688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67689     return ;
67690   }
67691   {
67692     try {
67693       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67694     } catch (std::out_of_range& e) {
67695       {
67696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67697       };
67698     } catch (std::exception& e) {
67699       {
67700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67701       };
67702     } catch (Dali::DaliException e) {
67703       {
67704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67705       };
67706     } catch (...) {
67707       {
67708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67709       };
67710     }
67711   }
67712
67713 }
67714
67715
67716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67717   void * jresult ;
67718   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67719   Dali::Vector4 result;
67720
67721   arg1 = (Dali::Toolkit::Control *)jarg1;
67722   {
67723     try {
67724       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67725     } catch (std::out_of_range& e) {
67726       {
67727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67728       };
67729     } catch (std::exception& e) {
67730       {
67731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67732       };
67733     } catch (Dali::DaliException e) {
67734       {
67735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67736       };
67737     } catch (...) {
67738       {
67739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67740       };
67741     }
67742   }
67743
67744   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67745   return jresult;
67746 }
67747
67748
67749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67750   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67751   Dali::Image arg2 ;
67752   Dali::Image *argp2 ;
67753
67754   arg1 = (Dali::Toolkit::Control *)jarg1;
67755   argp2 = (Dali::Image *)jarg2;
67756   if (!argp2) {
67757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67758     return ;
67759   }
67760   arg2 = *argp2;
67761   {
67762     try {
67763       (arg1)->SetBackgroundImage(arg2);
67764     } catch (std::out_of_range& e) {
67765       {
67766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67767       };
67768     } catch (std::exception& e) {
67769       {
67770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67771       };
67772     } catch (Dali::DaliException e) {
67773       {
67774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67775       };
67776     } catch (...) {
67777       {
67778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67779       };
67780     }
67781   }
67782
67783 }
67784
67785
67786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67787   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67788
67789   arg1 = (Dali::Toolkit::Control *)jarg1;
67790   {
67791     try {
67792       (arg1)->ClearBackground();
67793     } catch (std::out_of_range& e) {
67794       {
67795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67796       };
67797     } catch (std::exception& e) {
67798       {
67799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67800       };
67801     } catch (Dali::DaliException e) {
67802       {
67803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67804       };
67805     } catch (...) {
67806       {
67807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67808       };
67809     }
67810   }
67811
67812 }
67813
67814
67815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67816   void * jresult ;
67817   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67818   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67819
67820   arg1 = (Dali::Toolkit::Control *)jarg1;
67821   {
67822     try {
67823       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67824     } catch (std::out_of_range& e) {
67825       {
67826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67827       };
67828     } catch (std::exception& e) {
67829       {
67830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67831       };
67832     } catch (Dali::DaliException e) {
67833       {
67834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67835       };
67836     } catch (...) {
67837       {
67838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67839       };
67840     }
67841   }
67842
67843   jresult = (void *)result;
67844   return jresult;
67845 }
67846
67847
67848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67849   void * jresult ;
67850   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67851   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67852
67853   arg1 = (Dali::Toolkit::Control *)jarg1;
67854   {
67855     try {
67856       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67857     } catch (std::out_of_range& e) {
67858       {
67859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67860       };
67861     } catch (std::exception& e) {
67862       {
67863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67864       };
67865     } catch (Dali::DaliException e) {
67866       {
67867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67868       };
67869     } catch (...) {
67870       {
67871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67872       };
67873     }
67874   }
67875
67876   jresult = (void *)result;
67877   return jresult;
67878 }
67879
67880
67881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67882   void * jresult ;
67883   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67884   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67885
67886   arg1 = (Dali::Toolkit::Control *)jarg1;
67887   {
67888     try {
67889       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67890     } catch (std::out_of_range& e) {
67891       {
67892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67893       };
67894     } catch (std::exception& e) {
67895       {
67896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67897       };
67898     } catch (Dali::DaliException e) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67901       };
67902     } catch (...) {
67903       {
67904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67905       };
67906     }
67907   }
67908
67909   jresult = (void *)result;
67910   return jresult;
67911 }
67912
67913
67914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67915   void * jresult ;
67916   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67917   Dali::Toolkit::Control *result = 0 ;
67918
67919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67920   if (!arg1) {
67921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67922     return 0;
67923   }
67924   {
67925     try {
67926       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67927     } catch (std::out_of_range& e) {
67928       {
67929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67930       };
67931     } catch (std::exception& e) {
67932       {
67933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67934       };
67935     } catch (Dali::DaliException e) {
67936       {
67937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67938       };
67939     } catch (...) {
67940       {
67941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67942       };
67943     }
67944   }
67945
67946   jresult = (void *)result;
67947   return jresult;
67948 }
67949
67950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67951 {
67952   int jresult;
67953   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67954   arg1 = (Dali::Toolkit::Control *)jarg1;
67955
67956   if (!arg1) {
67957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67958     return 0;
67959   }
67960
67961   Dali::Property::Index arg2 = 0 ;
67962   arg2 = (Dali::Property::Index)jarg2;
67963
67964   Toolkit::Visual::ResourceStatus result;
67965   {
67966     try {
67967       result = arg1->GetVisualResourceStatus(arg2);
67968     } catch (std::out_of_range& e) {
67969       {
67970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67971       };
67972     } catch (std::exception& e) {
67973       {
67974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67975       };
67976     } catch (...) {
67977       {
67978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67979       };
67980     }
67981   }
67982   jresult = (int)(result);
67983   return jresult;
67984 }
67985
67986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67987 {
67988   void * jresult;
67989   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67990   arg1 = (Dali::Toolkit::Control *)jarg1;
67991
67992   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67993
67994   Dali::Toolkit::TransitionData *arg2 = 0 ;
67995   Dali::Animation result;
67996
67997   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67998   if (!arg2) {
67999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68000     return 0;
68001   }
68002   {
68003     try {
68004       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68005     } catch (std::out_of_range& e) {
68006       {
68007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68008       };
68009     } catch (std::exception& e) {
68010       {
68011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68012       };
68013     } catch (Dali::DaliException e) {
68014       {
68015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68016       };
68017     } catch (...) {
68018       {
68019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68020       };
68021     }
68022   }
68023
68024   jresult = new Dali::Animation((const Dali::Animation &)result);
68025   return jresult;
68026 }
68027
68028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68029 {
68030   Dali::Toolkit::Control arg1;
68031   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68032
68033   if (!argp1) {
68034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68035   }
68036   arg1 = *argp1;
68037
68038   Dali::Property::Index arg2 = 0 ;
68039   arg2 = (Dali::Property::Index)jarg2;
68040
68041   Dali::Property::Index arg3 = 0 ;
68042   arg3 = (Dali::Property::Index)jarg3;
68043
68044   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
68045
68046   {
68047     try {
68048       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
68049     } catch (std::out_of_range& e) {
68050       {
68051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68052       };
68053     } catch (std::exception& e) {
68054       {
68055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68056       };
68057     } catch (...) {
68058       {
68059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68060       };
68061     }
68062   }
68063
68064
68065 }
68066
68067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68068   void * jresult ;
68069   Dali::Toolkit::Control *arg1 = 0 ;
68070   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68071
68072   arg1 = (Dali::Toolkit::Control *)jarg1;
68073   if (!arg1) {
68074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68075     return 0;
68076   }
68077   {
68078     try {
68079       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68080     } catch (std::out_of_range& e) {
68081       {
68082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68083       };
68084     } catch (std::exception& e) {
68085       {
68086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68087       };
68088     } catch (Dali::DaliException e) {
68089       {
68090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68091       };
68092     } catch (...) {
68093       {
68094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68095       };
68096     }
68097   }
68098
68099   jresult = (void *)result;
68100   return jresult;
68101 }
68102
68103
68104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68105   unsigned int jresult ;
68106   Dali::Toolkit::Control *arg1 = 0 ;
68107   bool result;
68108
68109   arg1 = (Dali::Toolkit::Control *)jarg1;
68110   if (!arg1) {
68111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68112     return 0;
68113   }
68114   {
68115     try {
68116       result = (bool)arg1->IsResourceReady();
68117     } catch (std::out_of_range& e) {
68118       {
68119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68120       };
68121     } catch (std::exception& e) {
68122       {
68123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68124       };
68125     } catch (Dali::DaliException e) {
68126       {
68127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68128       };
68129     } catch (...) {
68130       {
68131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68132       };
68133     }
68134   }
68135
68136   jresult = result;
68137   return jresult;
68138 }
68139
68140
68141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68142   void * jresult ;
68143   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68144
68145   {
68146     try {
68147       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68148     } catch (std::out_of_range& e) {
68149       {
68150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68151       };
68152     } catch (std::exception& e) {
68153       {
68154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68155       };
68156     } catch (Dali::DaliException e) {
68157       {
68158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68159       };
68160     } catch (...) {
68161       {
68162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68163       };
68164     }
68165   }
68166
68167   jresult = (void *)result;
68168   return jresult;
68169 }
68170
68171
68172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68173   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68174
68175   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68176   {
68177     try {
68178       delete arg1;
68179     } catch (std::out_of_range& e) {
68180       {
68181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68182       };
68183     } catch (std::exception& e) {
68184       {
68185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68186       };
68187     } catch (Dali::DaliException e) {
68188       {
68189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68190       };
68191     } catch (...) {
68192       {
68193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68194       };
68195     }
68196   }
68197
68198 }
68199
68200
68201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68202   void * jresult ;
68203   Dali::Toolkit::KeyInputFocusManager result;
68204
68205   {
68206     try {
68207       result = Dali::Toolkit::KeyInputFocusManager::Get();
68208     } catch (std::out_of_range& e) {
68209       {
68210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68211       };
68212     } catch (std::exception& e) {
68213       {
68214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68215       };
68216     } catch (Dali::DaliException e) {
68217       {
68218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68219       };
68220     } catch (...) {
68221       {
68222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68223       };
68224     }
68225   }
68226
68227   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68228   return jresult;
68229 }
68230
68231
68232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68233   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68234   Dali::Toolkit::Control arg2 ;
68235   Dali::Toolkit::Control *argp2 ;
68236
68237   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68238   argp2 = (Dali::Toolkit::Control *)jarg2;
68239   if (!argp2) {
68240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68241     return ;
68242   }
68243   arg2 = *argp2;
68244   {
68245     try {
68246       (arg1)->SetFocus(arg2);
68247     } catch (std::out_of_range& e) {
68248       {
68249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68250       };
68251     } catch (std::exception& e) {
68252       {
68253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68254       };
68255     } catch (Dali::DaliException e) {
68256       {
68257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68258       };
68259     } catch (...) {
68260       {
68261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68262       };
68263     }
68264   }
68265
68266 }
68267
68268
68269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68270   void * jresult ;
68271   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68272   Dali::Toolkit::Control result;
68273
68274   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68275   {
68276     try {
68277       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68278     } catch (std::out_of_range& e) {
68279       {
68280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68281       };
68282     } catch (std::exception& e) {
68283       {
68284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68285       };
68286     } catch (Dali::DaliException e) {
68287       {
68288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68289       };
68290     } catch (...) {
68291       {
68292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68293       };
68294     }
68295   }
68296
68297   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68298   return jresult;
68299 }
68300
68301
68302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68303   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68304   Dali::Toolkit::Control arg2 ;
68305   Dali::Toolkit::Control *argp2 ;
68306
68307   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68308   argp2 = (Dali::Toolkit::Control *)jarg2;
68309   if (!argp2) {
68310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68311     return ;
68312   }
68313   arg2 = *argp2;
68314   {
68315     try {
68316       (arg1)->RemoveFocus(arg2);
68317     } catch (std::out_of_range& e) {
68318       {
68319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68320       };
68321     } catch (std::exception& e) {
68322       {
68323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68324       };
68325     } catch (Dali::DaliException e) {
68326       {
68327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68328       };
68329     } catch (...) {
68330       {
68331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68332       };
68333     }
68334   }
68335
68336 }
68337
68338
68339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68340   void * jresult ;
68341   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68342   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68343
68344   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68345   {
68346     try {
68347       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68348     } catch (std::out_of_range& e) {
68349       {
68350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68351       };
68352     } catch (std::exception& e) {
68353       {
68354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68355       };
68356     } catch (Dali::DaliException e) {
68357       {
68358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68359       };
68360     } catch (...) {
68361       {
68362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68363       };
68364     }
68365   }
68366
68367   jresult = (void *)result;
68368   return jresult;
68369 }
68370
68371
68372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68373   void * jresult ;
68374   Dali::Toolkit::Alignment::Padding *result = 0 ;
68375
68376   {
68377     try {
68378       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68379     } catch (std::out_of_range& e) {
68380       {
68381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68382       };
68383     } catch (std::exception& e) {
68384       {
68385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68386       };
68387     } catch (Dali::DaliException e) {
68388       {
68389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68390       };
68391     } catch (...) {
68392       {
68393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68394       };
68395     }
68396   }
68397
68398   jresult = (void *)result;
68399   return jresult;
68400 }
68401
68402
68403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68404   void * jresult ;
68405   float arg1 ;
68406   float arg2 ;
68407   float arg3 ;
68408   float arg4 ;
68409   Dali::Toolkit::Alignment::Padding *result = 0 ;
68410
68411   arg1 = (float)jarg1;
68412   arg2 = (float)jarg2;
68413   arg3 = (float)jarg3;
68414   arg4 = (float)jarg4;
68415   {
68416     try {
68417       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68418     } catch (std::out_of_range& e) {
68419       {
68420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68421       };
68422     } catch (std::exception& e) {
68423       {
68424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68425       };
68426     } catch (Dali::DaliException e) {
68427       {
68428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68429       };
68430     } catch (...) {
68431       {
68432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68433       };
68434     }
68435   }
68436
68437   jresult = (void *)result;
68438   return jresult;
68439 }
68440
68441
68442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68443   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68444   float arg2 ;
68445
68446   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68447   arg2 = (float)jarg2;
68448   if (arg1) (arg1)->left = arg2;
68449 }
68450
68451
68452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68453   float jresult ;
68454   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68455   float result;
68456
68457   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68458   result = (float) ((arg1)->left);
68459   jresult = result;
68460   return jresult;
68461 }
68462
68463
68464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68465   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68466   float arg2 ;
68467
68468   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68469   arg2 = (float)jarg2;
68470   if (arg1) (arg1)->right = arg2;
68471 }
68472
68473
68474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68475   float jresult ;
68476   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68477   float result;
68478
68479   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68480   result = (float) ((arg1)->right);
68481   jresult = result;
68482   return jresult;
68483 }
68484
68485
68486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68487   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68488   float arg2 ;
68489
68490   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68491   arg2 = (float)jarg2;
68492   if (arg1) (arg1)->top = arg2;
68493 }
68494
68495
68496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68497   float jresult ;
68498   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68499   float result;
68500
68501   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68502   result = (float) ((arg1)->top);
68503   jresult = result;
68504   return jresult;
68505 }
68506
68507
68508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68509   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68510   float arg2 ;
68511
68512   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68513   arg2 = (float)jarg2;
68514   if (arg1) (arg1)->bottom = arg2;
68515 }
68516
68517
68518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68519   float jresult ;
68520   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68521   float result;
68522
68523   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68524   result = (float) ((arg1)->bottom);
68525   jresult = result;
68526   return jresult;
68527 }
68528
68529
68530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68531   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68532
68533   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68534   {
68535     try {
68536       delete arg1;
68537     } catch (std::out_of_range& e) {
68538       {
68539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68540       };
68541     } catch (std::exception& e) {
68542       {
68543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68544       };
68545     } catch (Dali::DaliException e) {
68546       {
68547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68548       };
68549     } catch (...) {
68550       {
68551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68552       };
68553     }
68554   }
68555
68556 }
68557
68558
68559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68560   void * jresult ;
68561   Dali::Toolkit::Alignment *result = 0 ;
68562
68563   {
68564     try {
68565       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68566     } catch (std::out_of_range& e) {
68567       {
68568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68569       };
68570     } catch (std::exception& e) {
68571       {
68572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68573       };
68574     } catch (Dali::DaliException e) {
68575       {
68576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68577       };
68578     } catch (...) {
68579       {
68580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68581       };
68582     }
68583   }
68584
68585   jresult = (void *)result;
68586   return jresult;
68587 }
68588
68589
68590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68591   void * jresult ;
68592   Dali::Toolkit::Alignment::Type arg1 ;
68593   Dali::Toolkit::Alignment::Type arg2 ;
68594   Dali::Toolkit::Alignment result;
68595
68596   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68597   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68598   {
68599     try {
68600       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68601     } catch (std::out_of_range& e) {
68602       {
68603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68604       };
68605     } catch (std::exception& e) {
68606       {
68607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68608       };
68609     } catch (Dali::DaliException e) {
68610       {
68611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68612       };
68613     } catch (...) {
68614       {
68615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68616       };
68617     }
68618   }
68619
68620   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68621   return jresult;
68622 }
68623
68624
68625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68626   void * jresult ;
68627   Dali::Toolkit::Alignment::Type arg1 ;
68628   Dali::Toolkit::Alignment result;
68629
68630   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68631   {
68632     try {
68633       result = Dali::Toolkit::Alignment::New(arg1);
68634     } catch (std::out_of_range& e) {
68635       {
68636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68637       };
68638     } catch (std::exception& e) {
68639       {
68640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68641       };
68642     } catch (Dali::DaliException e) {
68643       {
68644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68645       };
68646     } catch (...) {
68647       {
68648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68649       };
68650     }
68651   }
68652
68653   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68654   return jresult;
68655 }
68656
68657
68658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68659   void * jresult ;
68660   Dali::Toolkit::Alignment result;
68661
68662   {
68663     try {
68664       result = Dali::Toolkit::Alignment::New();
68665     } catch (std::out_of_range& e) {
68666       {
68667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68668       };
68669     } catch (std::exception& e) {
68670       {
68671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68672       };
68673     } catch (Dali::DaliException e) {
68674       {
68675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68676       };
68677     } catch (...) {
68678       {
68679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68680       };
68681     }
68682   }
68683
68684   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68685   return jresult;
68686 }
68687
68688
68689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68690   void * jresult ;
68691   Dali::Toolkit::Alignment *arg1 = 0 ;
68692   Dali::Toolkit::Alignment *result = 0 ;
68693
68694   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68695   if (!arg1) {
68696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68697     return 0;
68698   }
68699   {
68700     try {
68701       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68702     } catch (std::out_of_range& e) {
68703       {
68704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68705       };
68706     } catch (std::exception& e) {
68707       {
68708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68709       };
68710     } catch (Dali::DaliException e) {
68711       {
68712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68713       };
68714     } catch (...) {
68715       {
68716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68717       };
68718     }
68719   }
68720
68721   jresult = (void *)result;
68722   return jresult;
68723 }
68724
68725
68726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68727   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68728
68729   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68730   {
68731     try {
68732       delete arg1;
68733     } catch (std::out_of_range& e) {
68734       {
68735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68736       };
68737     } catch (std::exception& e) {
68738       {
68739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68740       };
68741     } catch (Dali::DaliException e) {
68742       {
68743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68744       };
68745     } catch (...) {
68746       {
68747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68748       };
68749     }
68750   }
68751
68752 }
68753
68754
68755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68756   void * jresult ;
68757   Dali::BaseHandle arg1 ;
68758   Dali::BaseHandle *argp1 ;
68759   Dali::Toolkit::Alignment result;
68760
68761   argp1 = (Dali::BaseHandle *)jarg1;
68762   if (!argp1) {
68763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68764     return 0;
68765   }
68766   arg1 = *argp1;
68767   {
68768     try {
68769       result = Dali::Toolkit::Alignment::DownCast(arg1);
68770     } catch (std::out_of_range& e) {
68771       {
68772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68773       };
68774     } catch (std::exception& e) {
68775       {
68776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68777       };
68778     } catch (Dali::DaliException e) {
68779       {
68780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68781       };
68782     } catch (...) {
68783       {
68784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68785       };
68786     }
68787   }
68788
68789   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68790   return jresult;
68791 }
68792
68793
68794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68795   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68796   Dali::Toolkit::Alignment::Type arg2 ;
68797
68798   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68799   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68800   {
68801     try {
68802       (arg1)->SetAlignmentType(arg2);
68803     } catch (std::out_of_range& e) {
68804       {
68805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68806       };
68807     } catch (std::exception& e) {
68808       {
68809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68810       };
68811     } catch (Dali::DaliException e) {
68812       {
68813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68814       };
68815     } catch (...) {
68816       {
68817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68818       };
68819     }
68820   }
68821
68822 }
68823
68824
68825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68826   int jresult ;
68827   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68828   Dali::Toolkit::Alignment::Type result;
68829
68830   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68831   {
68832     try {
68833       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68834     } catch (std::out_of_range& e) {
68835       {
68836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68837       };
68838     } catch (std::exception& e) {
68839       {
68840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68841       };
68842     } catch (Dali::DaliException e) {
68843       {
68844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68845       };
68846     } catch (...) {
68847       {
68848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68849       };
68850     }
68851   }
68852
68853   jresult = (int)result;
68854   return jresult;
68855 }
68856
68857
68858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68859   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68860   Dali::Toolkit::Alignment::Scaling arg2 ;
68861
68862   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68863   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68864   {
68865     try {
68866       (arg1)->SetScaling(arg2);
68867     } catch (std::out_of_range& e) {
68868       {
68869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68870       };
68871     } catch (std::exception& e) {
68872       {
68873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68874       };
68875     } catch (Dali::DaliException e) {
68876       {
68877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68878       };
68879     } catch (...) {
68880       {
68881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68882       };
68883     }
68884   }
68885
68886 }
68887
68888
68889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68890   int jresult ;
68891   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68892   Dali::Toolkit::Alignment::Scaling result;
68893
68894   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68895   {
68896     try {
68897       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68898     } catch (std::out_of_range& e) {
68899       {
68900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68901       };
68902     } catch (std::exception& e) {
68903       {
68904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68905       };
68906     } catch (Dali::DaliException e) {
68907       {
68908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68909       };
68910     } catch (...) {
68911       {
68912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68913       };
68914     }
68915   }
68916
68917   jresult = (int)result;
68918   return jresult;
68919 }
68920
68921
68922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68923   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68924   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68925
68926   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68927   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68928   if (!arg2) {
68929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68930     return ;
68931   }
68932   {
68933     try {
68934       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68935     } catch (std::out_of_range& e) {
68936       {
68937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68938       };
68939     } catch (std::exception& e) {
68940       {
68941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68942       };
68943     } catch (Dali::DaliException e) {
68944       {
68945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68946       };
68947     } catch (...) {
68948       {
68949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68950       };
68951     }
68952   }
68953
68954 }
68955
68956
68957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68958   void * jresult ;
68959   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68960   Dali::Toolkit::Alignment::Padding *result = 0 ;
68961
68962   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68963   {
68964     try {
68965       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68966     } catch (std::out_of_range& e) {
68967       {
68968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68969       };
68970     } catch (std::exception& e) {
68971       {
68972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68973       };
68974     } catch (Dali::DaliException e) {
68975       {
68976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68977       };
68978     } catch (...) {
68979       {
68980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68981       };
68982     }
68983   }
68984
68985   jresult = (void *)result;
68986   return jresult;
68987 }
68988
68989
68990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68991   void * jresult ;
68992   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68993   Dali::Toolkit::Alignment *arg2 = 0 ;
68994   Dali::Toolkit::Alignment *result = 0 ;
68995
68996   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68997   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68998   if (!arg2) {
68999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69000     return 0;
69001   }
69002   {
69003     try {
69004       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69005     } catch (std::out_of_range& e) {
69006       {
69007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69008       };
69009     } catch (std::exception& e) {
69010       {
69011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69012       };
69013     } catch (Dali::DaliException e) {
69014       {
69015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69016       };
69017     } catch (...) {
69018       {
69019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69020       };
69021     }
69022   }
69023
69024   jresult = (void *)result;
69025   return jresult;
69026 }
69027
69028
69029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69030   int jresult ;
69031   int result;
69032
69033   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69034   jresult = (int)result;
69035   return jresult;
69036 }
69037
69038
69039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69040   int jresult ;
69041   int result;
69042
69043   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69044   jresult = (int)result;
69045   return jresult;
69046 }
69047
69048
69049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69050   int jresult ;
69051   int result;
69052
69053   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69054   jresult = (int)result;
69055   return jresult;
69056 }
69057
69058
69059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69060   int jresult ;
69061   int result;
69062
69063   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69064   jresult = (int)result;
69065   return jresult;
69066 }
69067
69068
69069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69070   int jresult ;
69071   int result;
69072
69073   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69074   jresult = (int)result;
69075   return jresult;
69076 }
69077
69078
69079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69080   int jresult ;
69081   int result;
69082
69083   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69084   jresult = (int)result;
69085   return jresult;
69086 }
69087
69088
69089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69090   int jresult ;
69091   int result;
69092
69093   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69094   jresult = (int)result;
69095   return jresult;
69096 }
69097
69098
69099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69100   int jresult ;
69101   int result;
69102
69103   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69104   jresult = (int)result;
69105   return jresult;
69106 }
69107
69108
69109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69110   int jresult ;
69111   int result;
69112
69113   result = (int)Dali::Toolkit::Button::Property::LABEL;
69114   jresult = (int)result;
69115   return jresult;
69116 }
69117
69118
69119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69120   int jresult ;
69121   int result;
69122
69123   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69124   jresult = (int)result;
69125   return jresult;
69126 }
69127
69128
69129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69130   void * jresult ;
69131   Dali::Toolkit::Button::Property *result = 0 ;
69132
69133   {
69134     try {
69135       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69136     } catch (std::out_of_range& e) {
69137       {
69138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69139       };
69140     } catch (std::exception& e) {
69141       {
69142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69143       };
69144     } catch (Dali::DaliException e) {
69145       {
69146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69147       };
69148     } catch (...) {
69149       {
69150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69151       };
69152     }
69153   }
69154
69155   jresult = (void *)result;
69156   return jresult;
69157 }
69158
69159
69160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69161   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69162
69163   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69164   {
69165     try {
69166       delete arg1;
69167     } catch (std::out_of_range& e) {
69168       {
69169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69170       };
69171     } catch (std::exception& e) {
69172       {
69173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69174       };
69175     } catch (Dali::DaliException e) {
69176       {
69177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69178       };
69179     } catch (...) {
69180       {
69181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69182       };
69183     }
69184   }
69185
69186 }
69187
69188
69189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69190   void * jresult ;
69191   Dali::Toolkit::Button *result = 0 ;
69192
69193   {
69194     try {
69195       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69196     } catch (std::out_of_range& e) {
69197       {
69198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69199       };
69200     } catch (std::exception& e) {
69201       {
69202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69203       };
69204     } catch (Dali::DaliException e) {
69205       {
69206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69207       };
69208     } catch (...) {
69209       {
69210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69211       };
69212     }
69213   }
69214
69215   jresult = (void *)result;
69216   return jresult;
69217 }
69218
69219
69220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69221   void * jresult ;
69222   Dali::Toolkit::Button *arg1 = 0 ;
69223   Dali::Toolkit::Button *result = 0 ;
69224
69225   arg1 = (Dali::Toolkit::Button *)jarg1;
69226   if (!arg1) {
69227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69228     return 0;
69229   }
69230   {
69231     try {
69232       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69233     } catch (std::out_of_range& e) {
69234       {
69235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69236       };
69237     } catch (std::exception& e) {
69238       {
69239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69240       };
69241     } catch (Dali::DaliException e) {
69242       {
69243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69244       };
69245     } catch (...) {
69246       {
69247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69248       };
69249     }
69250   }
69251
69252   jresult = (void *)result;
69253   return jresult;
69254 }
69255
69256
69257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69258   void * jresult ;
69259   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69260   Dali::Toolkit::Button *arg2 = 0 ;
69261   Dali::Toolkit::Button *result = 0 ;
69262
69263   arg1 = (Dali::Toolkit::Button *)jarg1;
69264   arg2 = (Dali::Toolkit::Button *)jarg2;
69265   if (!arg2) {
69266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69267     return 0;
69268   }
69269   {
69270     try {
69271       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69272     } catch (std::out_of_range& e) {
69273       {
69274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69275       };
69276     } catch (std::exception& e) {
69277       {
69278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69279       };
69280     } catch (Dali::DaliException e) {
69281       {
69282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69283       };
69284     } catch (...) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69287       };
69288     }
69289   }
69290
69291   jresult = (void *)result;
69292   return jresult;
69293 }
69294
69295
69296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69297   void * jresult ;
69298   Dali::BaseHandle arg1 ;
69299   Dali::BaseHandle *argp1 ;
69300   Dali::Toolkit::Button result;
69301
69302   argp1 = (Dali::BaseHandle *)jarg1;
69303   if (!argp1) {
69304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69305     return 0;
69306   }
69307   arg1 = *argp1;
69308   {
69309     try {
69310       result = Dali::Toolkit::Button::DownCast(arg1);
69311     } catch (std::out_of_range& e) {
69312       {
69313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69314       };
69315     } catch (std::exception& e) {
69316       {
69317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69318       };
69319     } catch (Dali::DaliException e) {
69320       {
69321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69322       };
69323     } catch (...) {
69324       {
69325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69326       };
69327     }
69328   }
69329
69330   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69331   return jresult;
69332 }
69333
69334
69335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69336   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69337
69338   arg1 = (Dali::Toolkit::Button *)jarg1;
69339   {
69340     try {
69341       delete arg1;
69342     } catch (std::out_of_range& e) {
69343       {
69344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69345       };
69346     } catch (std::exception& e) {
69347       {
69348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69349       };
69350     } catch (Dali::DaliException e) {
69351       {
69352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69353       };
69354     } catch (...) {
69355       {
69356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69357       };
69358     }
69359   }
69360
69361 }
69362
69363
69364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69365   unsigned int jresult ;
69366   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69367   bool result;
69368
69369   arg1 = (Dali::Toolkit::Button *)jarg1;
69370   {
69371     try {
69372       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69373     } catch (std::out_of_range& e) {
69374       {
69375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69376       };
69377     } catch (std::exception& e) {
69378       {
69379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69380       };
69381     } catch (Dali::DaliException e) {
69382       {
69383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69384       };
69385     } catch (...) {
69386       {
69387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69388       };
69389     }
69390   }
69391
69392   jresult = result;
69393   return jresult;
69394 }
69395
69396
69397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69398   unsigned int jresult ;
69399   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69400   bool result;
69401
69402   arg1 = (Dali::Toolkit::Button *)jarg1;
69403   {
69404     try {
69405       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69406     } catch (std::out_of_range& e) {
69407       {
69408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69409       };
69410     } catch (std::exception& e) {
69411       {
69412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69413       };
69414     } catch (Dali::DaliException e) {
69415       {
69416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69417       };
69418     } catch (...) {
69419       {
69420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69421       };
69422     }
69423   }
69424
69425   jresult = result;
69426   return jresult;
69427 }
69428
69429
69430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69431   float jresult ;
69432   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69433   float result;
69434
69435   arg1 = (Dali::Toolkit::Button *)jarg1;
69436   {
69437     try {
69438       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69439     } catch (std::out_of_range& e) {
69440       {
69441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69442       };
69443     } catch (std::exception& e) {
69444       {
69445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69446       };
69447     } catch (Dali::DaliException e) {
69448       {
69449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69450       };
69451     } catch (...) {
69452       {
69453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69454       };
69455     }
69456   }
69457
69458   jresult = result;
69459   return jresult;
69460 }
69461
69462
69463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69464   float jresult ;
69465   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69466   float result;
69467
69468   arg1 = (Dali::Toolkit::Button *)jarg1;
69469   {
69470     try {
69471       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69472     } catch (std::out_of_range& e) {
69473       {
69474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69475       };
69476     } catch (std::exception& e) {
69477       {
69478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69479       };
69480     } catch (Dali::DaliException e) {
69481       {
69482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69483       };
69484     } catch (...) {
69485       {
69486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69487       };
69488     }
69489   }
69490
69491   jresult = result;
69492   return jresult;
69493 }
69494
69495
69496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69497   unsigned int jresult ;
69498   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69499   bool result;
69500
69501   arg1 = (Dali::Toolkit::Button *)jarg1;
69502   {
69503     try {
69504       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69505     } catch (std::out_of_range& e) {
69506       {
69507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69508       };
69509     } catch (std::exception& e) {
69510       {
69511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69512       };
69513     } catch (Dali::DaliException e) {
69514       {
69515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69516       };
69517     } catch (...) {
69518       {
69519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69520       };
69521     }
69522   }
69523
69524   jresult = result;
69525   return jresult;
69526 }
69527
69528
69529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69530   unsigned int jresult ;
69531   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69532   bool result;
69533
69534   arg1 = (Dali::Toolkit::Button *)jarg1;
69535   {
69536     try {
69537       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69538     } catch (std::out_of_range& e) {
69539       {
69540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69541       };
69542     } catch (std::exception& e) {
69543       {
69544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69545       };
69546     } catch (Dali::DaliException e) {
69547       {
69548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69549       };
69550     } catch (...) {
69551       {
69552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69553       };
69554     }
69555   }
69556
69557   jresult = result;
69558   return jresult;
69559 }
69560
69561
69562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69563   float jresult ;
69564   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69565   float result;
69566
69567   arg1 = (Dali::Toolkit::Button *)jarg1;
69568   {
69569     try {
69570       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69571     } catch (std::out_of_range& e) {
69572       {
69573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69574       };
69575     } catch (std::exception& e) {
69576       {
69577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69578       };
69579     } catch (Dali::DaliException e) {
69580       {
69581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69582       };
69583     } catch (...) {
69584       {
69585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69586       };
69587     }
69588   }
69589
69590   jresult = result;
69591   return jresult;
69592 }
69593
69594
69595 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69596   char * jresult ;
69597   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69598   std::string result;
69599
69600   arg1 = (Dali::Toolkit::Button *)jarg1;
69601   {
69602     try {
69603       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69604     } catch (std::out_of_range& e) {
69605       {
69606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69607       };
69608     } catch (std::exception& e) {
69609       {
69610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69611       };
69612     } catch (Dali::DaliException e) {
69613       {
69614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69615       };
69616     } catch (...) {
69617       {
69618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69619       };
69620     }
69621   }
69622
69623   jresult = SWIG_csharp_string_callback((&result)->c_str());
69624   return jresult;
69625 }
69626
69627
69628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69629   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69630   Dali::Actor arg2 ;
69631   Dali::Actor *argp2 ;
69632
69633   arg1 = (Dali::Toolkit::Button *)jarg1;
69634   argp2 = (Dali::Actor *)jarg2;
69635   if (!argp2) {
69636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69637     return ;
69638   }
69639   arg2 = *argp2;
69640   {
69641     try {
69642       (arg1)->SetLabel(arg2);
69643     } catch (std::out_of_range& e) {
69644       {
69645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69646       };
69647     } catch (std::exception& e) {
69648       {
69649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69650       };
69651     } catch (Dali::DaliException e) {
69652       {
69653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69654       };
69655     } catch (...) {
69656       {
69657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69658       };
69659     }
69660   }
69661
69662 }
69663
69664
69665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69666   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69667   Dali::Image arg2 ;
69668   Dali::Image *argp2 ;
69669
69670   arg1 = (Dali::Toolkit::Button *)jarg1;
69671   argp2 = (Dali::Image *)jarg2;
69672   if (!argp2) {
69673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69674     return ;
69675   }
69676   arg2 = *argp2;
69677   {
69678     try {
69679       (arg1)->SetButtonImage(arg2);
69680     } catch (std::out_of_range& e) {
69681       {
69682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69683       };
69684     } catch (std::exception& e) {
69685       {
69686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69687       };
69688     } catch (Dali::DaliException e) {
69689       {
69690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69691       };
69692     } catch (...) {
69693       {
69694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69695       };
69696     }
69697   }
69698
69699 }
69700
69701
69702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69703   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69704   Dali::Image arg2 ;
69705   Dali::Image *argp2 ;
69706
69707   arg1 = (Dali::Toolkit::Button *)jarg1;
69708   argp2 = (Dali::Image *)jarg2;
69709   if (!argp2) {
69710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69711     return ;
69712   }
69713   arg2 = *argp2;
69714   {
69715     try {
69716       (arg1)->SetSelectedImage(arg2);
69717     } catch (std::out_of_range& e) {
69718       {
69719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69720       };
69721     } catch (std::exception& e) {
69722       {
69723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69724       };
69725     } catch (Dali::DaliException e) {
69726       {
69727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69728       };
69729     } catch (...) {
69730       {
69731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69732       };
69733     }
69734   }
69735
69736 }
69737
69738
69739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69740   void * jresult ;
69741   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69742   Dali::Actor result;
69743
69744   arg1 = (Dali::Toolkit::Button *)jarg1;
69745   {
69746     try {
69747       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69748     } catch (std::out_of_range& e) {
69749       {
69750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69751       };
69752     } catch (std::exception& e) {
69753       {
69754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69755       };
69756     } catch (Dali::DaliException e) {
69757       {
69758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69759       };
69760     } catch (...) {
69761       {
69762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69763       };
69764     }
69765   }
69766
69767   jresult = new Dali::Actor((const Dali::Actor &)result);
69768   return jresult;
69769 }
69770
69771
69772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69773   void * jresult ;
69774   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69775   Dali::Actor result;
69776
69777   arg1 = (Dali::Toolkit::Button *)jarg1;
69778   {
69779     try {
69780       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69781     } catch (std::out_of_range& e) {
69782       {
69783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69784       };
69785     } catch (std::exception& e) {
69786       {
69787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69788       };
69789     } catch (Dali::DaliException e) {
69790       {
69791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69792       };
69793     } catch (...) {
69794       {
69795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69796       };
69797     }
69798   }
69799
69800   jresult = new Dali::Actor((const Dali::Actor &)result);
69801   return jresult;
69802 }
69803
69804
69805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69806   void * jresult ;
69807   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69808   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69809
69810   arg1 = (Dali::Toolkit::Button *)jarg1;
69811   {
69812     try {
69813       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69814     } catch (std::out_of_range& e) {
69815       {
69816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69817       };
69818     } catch (std::exception& e) {
69819       {
69820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69821       };
69822     } catch (Dali::DaliException e) {
69823       {
69824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69825       };
69826     } catch (...) {
69827       {
69828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69829       };
69830     }
69831   }
69832
69833   jresult = (void *)result;
69834   return jresult;
69835 }
69836
69837
69838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69839   void * jresult ;
69840   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69841   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69842
69843   arg1 = (Dali::Toolkit::Button *)jarg1;
69844   {
69845     try {
69846       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69847     } catch (std::out_of_range& e) {
69848       {
69849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69850       };
69851     } catch (std::exception& e) {
69852       {
69853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69854       };
69855     } catch (Dali::DaliException e) {
69856       {
69857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69858       };
69859     } catch (...) {
69860       {
69861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69862       };
69863     }
69864   }
69865
69866   jresult = (void *)result;
69867   return jresult;
69868 }
69869
69870
69871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69872   void * jresult ;
69873   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69874   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69875
69876   arg1 = (Dali::Toolkit::Button *)jarg1;
69877   {
69878     try {
69879       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69880     } catch (std::out_of_range& e) {
69881       {
69882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69883       };
69884     } catch (std::exception& e) {
69885       {
69886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69887       };
69888     } catch (Dali::DaliException e) {
69889       {
69890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69891       };
69892     } catch (...) {
69893       {
69894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69895       };
69896     }
69897   }
69898
69899   jresult = (void *)result;
69900   return jresult;
69901 }
69902
69903
69904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69905   void * jresult ;
69906   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69907   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69908
69909   arg1 = (Dali::Toolkit::Button *)jarg1;
69910   {
69911     try {
69912       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69913     } catch (std::out_of_range& e) {
69914       {
69915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69916       };
69917     } catch (std::exception& e) {
69918       {
69919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69920       };
69921     } catch (Dali::DaliException e) {
69922       {
69923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69924       };
69925     } catch (...) {
69926       {
69927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69928       };
69929     }
69930   }
69931
69932   jresult = (void *)result;
69933   return jresult;
69934 }
69935
69936
69937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69938   void * jresult ;
69939   Dali::Toolkit::CheckBoxButton *result = 0 ;
69940
69941   {
69942     try {
69943       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69944     } catch (std::out_of_range& e) {
69945       {
69946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69947       };
69948     } catch (std::exception& e) {
69949       {
69950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69951       };
69952     } catch (Dali::DaliException e) {
69953       {
69954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69955       };
69956     } catch (...) {
69957       {
69958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69959       };
69960     }
69961   }
69962
69963   jresult = (void *)result;
69964   return jresult;
69965 }
69966
69967
69968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69969   void * jresult ;
69970   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69971   Dali::Toolkit::CheckBoxButton *result = 0 ;
69972
69973   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69974   if (!arg1) {
69975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69976     return 0;
69977   }
69978   {
69979     try {
69980       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69981     } catch (std::out_of_range& e) {
69982       {
69983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (std::exception& e) {
69986       {
69987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69988       };
69989     } catch (Dali::DaliException e) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69992       };
69993     } catch (...) {
69994       {
69995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69996       };
69997     }
69998   }
69999
70000   jresult = (void *)result;
70001   return jresult;
70002 }
70003
70004
70005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70006   void * jresult ;
70007   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70008   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70009   Dali::Toolkit::CheckBoxButton *result = 0 ;
70010
70011   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70012   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70013   if (!arg2) {
70014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70015     return 0;
70016   }
70017   {
70018     try {
70019       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70020     } catch (std::out_of_range& e) {
70021       {
70022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70023       };
70024     } catch (std::exception& e) {
70025       {
70026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70027       };
70028     } catch (Dali::DaliException e) {
70029       {
70030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70031       };
70032     } catch (...) {
70033       {
70034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70035       };
70036     }
70037   }
70038
70039   jresult = (void *)result;
70040   return jresult;
70041 }
70042
70043
70044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70045   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70046
70047   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70048   {
70049     try {
70050       delete arg1;
70051     } catch (std::out_of_range& e) {
70052       {
70053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70054       };
70055     } catch (std::exception& e) {
70056       {
70057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70058       };
70059     } catch (Dali::DaliException e) {
70060       {
70061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70062       };
70063     } catch (...) {
70064       {
70065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70066       };
70067     }
70068   }
70069
70070 }
70071
70072
70073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70074   void * jresult ;
70075   Dali::Toolkit::CheckBoxButton result;
70076
70077   {
70078     try {
70079       result = Dali::Toolkit::CheckBoxButton::New();
70080     } catch (std::out_of_range& e) {
70081       {
70082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70083       };
70084     } catch (std::exception& e) {
70085       {
70086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70087       };
70088     } catch (Dali::DaliException e) {
70089       {
70090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70091       };
70092     } catch (...) {
70093       {
70094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70095       };
70096     }
70097   }
70098
70099   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70100   return jresult;
70101 }
70102
70103
70104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70105   void * jresult ;
70106   Dali::BaseHandle arg1 ;
70107   Dali::BaseHandle *argp1 ;
70108   Dali::Toolkit::CheckBoxButton result;
70109
70110   argp1 = (Dali::BaseHandle *)jarg1;
70111   if (!argp1) {
70112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70113     return 0;
70114   }
70115   arg1 = *argp1;
70116   {
70117     try {
70118       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70119     } catch (std::out_of_range& e) {
70120       {
70121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70122       };
70123     } catch (std::exception& e) {
70124       {
70125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70126       };
70127     } catch (Dali::DaliException e) {
70128       {
70129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70130       };
70131     } catch (...) {
70132       {
70133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70134       };
70135     }
70136   }
70137
70138   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70139   return jresult;
70140 }
70141
70142
70143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70144   int jresult ;
70145   int result;
70146
70147   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70148   jresult = (int)result;
70149   return jresult;
70150 }
70151
70152
70153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70154   int jresult ;
70155   int result;
70156
70157   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70158   jresult = (int)result;
70159   return jresult;
70160 }
70161
70162
70163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70164   int jresult ;
70165   int result;
70166
70167   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70168   jresult = (int)result;
70169   return jresult;
70170 }
70171
70172
70173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70174   int jresult ;
70175   int result;
70176
70177   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70178   jresult = (int)result;
70179   return jresult;
70180 }
70181
70182
70183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70184   int jresult ;
70185   int result;
70186
70187   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70188   jresult = (int)result;
70189   return jresult;
70190 }
70191
70192
70193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70194   void * jresult ;
70195   Dali::Toolkit::PushButton::Property *result = 0 ;
70196
70197   {
70198     try {
70199       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70200     } catch (std::out_of_range& e) {
70201       {
70202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70203       };
70204     } catch (std::exception& e) {
70205       {
70206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70207       };
70208     } catch (Dali::DaliException e) {
70209       {
70210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70211       };
70212     } catch (...) {
70213       {
70214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70215       };
70216     }
70217   }
70218
70219   jresult = (void *)result;
70220   return jresult;
70221 }
70222
70223
70224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70225   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70226
70227   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70228   {
70229     try {
70230       delete arg1;
70231     } catch (std::out_of_range& e) {
70232       {
70233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70234       };
70235     } catch (std::exception& e) {
70236       {
70237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70238       };
70239     } catch (Dali::DaliException e) {
70240       {
70241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70242       };
70243     } catch (...) {
70244       {
70245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70246       };
70247     }
70248   }
70249
70250 }
70251
70252
70253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70254   void * jresult ;
70255   Dali::Toolkit::PushButton *result = 0 ;
70256
70257   {
70258     try {
70259       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70260     } catch (std::out_of_range& e) {
70261       {
70262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70263       };
70264     } catch (std::exception& e) {
70265       {
70266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70267       };
70268     } catch (Dali::DaliException e) {
70269       {
70270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70271       };
70272     } catch (...) {
70273       {
70274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70275       };
70276     }
70277   }
70278
70279   jresult = (void *)result;
70280   return jresult;
70281 }
70282
70283
70284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70285   void * jresult ;
70286   Dali::Toolkit::PushButton *arg1 = 0 ;
70287   Dali::Toolkit::PushButton *result = 0 ;
70288
70289   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70290   if (!arg1) {
70291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70292     return 0;
70293   }
70294   {
70295     try {
70296       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70297     } catch (std::out_of_range& e) {
70298       {
70299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70300       };
70301     } catch (std::exception& e) {
70302       {
70303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70304       };
70305     } catch (Dali::DaliException e) {
70306       {
70307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70308       };
70309     } catch (...) {
70310       {
70311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70312       };
70313     }
70314   }
70315
70316   jresult = (void *)result;
70317   return jresult;
70318 }
70319
70320
70321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70322   void * jresult ;
70323   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70324   Dali::Toolkit::PushButton *arg2 = 0 ;
70325   Dali::Toolkit::PushButton *result = 0 ;
70326
70327   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70328   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70329   if (!arg2) {
70330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70331     return 0;
70332   }
70333   {
70334     try {
70335       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70336     } catch (std::out_of_range& e) {
70337       {
70338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70339       };
70340     } catch (std::exception& e) {
70341       {
70342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70343       };
70344     } catch (Dali::DaliException e) {
70345       {
70346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70347       };
70348     } catch (...) {
70349       {
70350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70351       };
70352     }
70353   }
70354
70355   jresult = (void *)result;
70356   return jresult;
70357 }
70358
70359
70360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70361   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70362
70363   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70364   {
70365     try {
70366       delete arg1;
70367     } catch (std::out_of_range& e) {
70368       {
70369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70370       };
70371     } catch (std::exception& e) {
70372       {
70373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70374       };
70375     } catch (Dali::DaliException e) {
70376       {
70377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70378       };
70379     } catch (...) {
70380       {
70381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70382       };
70383     }
70384   }
70385
70386 }
70387
70388
70389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70390   void * jresult ;
70391   Dali::Toolkit::PushButton result;
70392
70393   {
70394     try {
70395       result = Dali::Toolkit::PushButton::New();
70396     } catch (std::out_of_range& e) {
70397       {
70398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70399       };
70400     } catch (std::exception& e) {
70401       {
70402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70403       };
70404     } catch (Dali::DaliException e) {
70405       {
70406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70407       };
70408     } catch (...) {
70409       {
70410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70411       };
70412     }
70413   }
70414
70415   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70416   return jresult;
70417 }
70418
70419
70420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70421   void * jresult ;
70422   Dali::BaseHandle arg1 ;
70423   Dali::BaseHandle *argp1 ;
70424   Dali::Toolkit::PushButton result;
70425
70426   argp1 = (Dali::BaseHandle *)jarg1;
70427   if (!argp1) {
70428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70429     return 0;
70430   }
70431   arg1 = *argp1;
70432   {
70433     try {
70434       result = Dali::Toolkit::PushButton::DownCast(arg1);
70435     } catch (std::out_of_range& e) {
70436       {
70437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70438       };
70439     } catch (std::exception& e) {
70440       {
70441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70442       };
70443     } catch (Dali::DaliException e) {
70444       {
70445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70446       };
70447     } catch (...) {
70448       {
70449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70450       };
70451     }
70452   }
70453
70454   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70455   return jresult;
70456 }
70457
70458
70459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70460   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70461   Dali::Image arg2 ;
70462   Dali::Image *argp2 ;
70463
70464   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70465   argp2 = (Dali::Image *)jarg2;
70466   if (!argp2) {
70467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70468     return ;
70469   }
70470   arg2 = *argp2;
70471   {
70472     try {
70473       (arg1)->SetButtonImage(arg2);
70474     } catch (std::out_of_range& e) {
70475       {
70476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70477       };
70478     } catch (std::exception& e) {
70479       {
70480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70481       };
70482     } catch (Dali::DaliException e) {
70483       {
70484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70485       };
70486     } catch (...) {
70487       {
70488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70489       };
70490     }
70491   }
70492
70493 }
70494
70495
70496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70497   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70498   Dali::Actor arg2 ;
70499   Dali::Actor *argp2 ;
70500
70501   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70502   argp2 = (Dali::Actor *)jarg2;
70503   if (!argp2) {
70504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70505     return ;
70506   }
70507   arg2 = *argp2;
70508   {
70509     try {
70510       (arg1)->SetButtonImage(arg2);
70511     } catch (std::out_of_range& e) {
70512       {
70513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70514       };
70515     } catch (std::exception& e) {
70516       {
70517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70518       };
70519     } catch (Dali::DaliException e) {
70520       {
70521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70522       };
70523     } catch (...) {
70524       {
70525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70526       };
70527     }
70528   }
70529
70530 }
70531
70532
70533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70534   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70535   Dali::Actor arg2 ;
70536   Dali::Actor *argp2 ;
70537
70538   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70539   argp2 = (Dali::Actor *)jarg2;
70540   if (!argp2) {
70541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70542     return ;
70543   }
70544   arg2 = *argp2;
70545   {
70546     try {
70547       (arg1)->SetBackgroundImage(arg2);
70548     } catch (std::out_of_range& e) {
70549       {
70550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70551       };
70552     } catch (std::exception& e) {
70553       {
70554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70555       };
70556     } catch (Dali::DaliException e) {
70557       {
70558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70559       };
70560     } catch (...) {
70561       {
70562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70563       };
70564     }
70565   }
70566
70567 }
70568
70569
70570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70571   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70572   Dali::Image arg2 ;
70573   Dali::Image *argp2 ;
70574
70575   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70576   argp2 = (Dali::Image *)jarg2;
70577   if (!argp2) {
70578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70579     return ;
70580   }
70581   arg2 = *argp2;
70582   {
70583     try {
70584       (arg1)->SetSelectedImage(arg2);
70585     } catch (std::out_of_range& e) {
70586       {
70587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70588       };
70589     } catch (std::exception& e) {
70590       {
70591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70592       };
70593     } catch (Dali::DaliException e) {
70594       {
70595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70596       };
70597     } catch (...) {
70598       {
70599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70600       };
70601     }
70602   }
70603
70604 }
70605
70606
70607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70608   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70609   Dali::Actor arg2 ;
70610   Dali::Actor *argp2 ;
70611
70612   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70613   argp2 = (Dali::Actor *)jarg2;
70614   if (!argp2) {
70615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70616     return ;
70617   }
70618   arg2 = *argp2;
70619   {
70620     try {
70621       (arg1)->SetSelectedImage(arg2);
70622     } catch (std::out_of_range& e) {
70623       {
70624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70625       };
70626     } catch (std::exception& e) {
70627       {
70628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70629       };
70630     } catch (Dali::DaliException e) {
70631       {
70632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70633       };
70634     } catch (...) {
70635       {
70636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70637       };
70638     }
70639   }
70640
70641 }
70642
70643
70644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70645   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70646   Dali::Actor arg2 ;
70647   Dali::Actor *argp2 ;
70648
70649   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70650   argp2 = (Dali::Actor *)jarg2;
70651   if (!argp2) {
70652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70653     return ;
70654   }
70655   arg2 = *argp2;
70656   {
70657     try {
70658       (arg1)->SetSelectedBackgroundImage(arg2);
70659     } catch (std::out_of_range& e) {
70660       {
70661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70662       };
70663     } catch (std::exception& e) {
70664       {
70665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70666       };
70667     } catch (Dali::DaliException e) {
70668       {
70669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70670       };
70671     } catch (...) {
70672       {
70673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70674       };
70675     }
70676   }
70677
70678 }
70679
70680
70681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70682   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70683   Dali::Actor arg2 ;
70684   Dali::Actor *argp2 ;
70685
70686   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70687   argp2 = (Dali::Actor *)jarg2;
70688   if (!argp2) {
70689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70690     return ;
70691   }
70692   arg2 = *argp2;
70693   {
70694     try {
70695       (arg1)->SetDisabledBackgroundImage(arg2);
70696     } catch (std::out_of_range& e) {
70697       {
70698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70699       };
70700     } catch (std::exception& e) {
70701       {
70702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70703       };
70704     } catch (Dali::DaliException e) {
70705       {
70706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70707       };
70708     } catch (...) {
70709       {
70710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70711       };
70712     }
70713   }
70714
70715 }
70716
70717
70718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70719   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70720   Dali::Actor arg2 ;
70721   Dali::Actor *argp2 ;
70722
70723   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70724   argp2 = (Dali::Actor *)jarg2;
70725   if (!argp2) {
70726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70727     return ;
70728   }
70729   arg2 = *argp2;
70730   {
70731     try {
70732       (arg1)->SetDisabledImage(arg2);
70733     } catch (std::out_of_range& e) {
70734       {
70735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70736       };
70737     } catch (std::exception& e) {
70738       {
70739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70740       };
70741     } catch (Dali::DaliException e) {
70742       {
70743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70744       };
70745     } catch (...) {
70746       {
70747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70748       };
70749     }
70750   }
70751
70752 }
70753
70754
70755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70756   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70757   Dali::Actor arg2 ;
70758   Dali::Actor *argp2 ;
70759
70760   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70761   argp2 = (Dali::Actor *)jarg2;
70762   if (!argp2) {
70763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70764     return ;
70765   }
70766   arg2 = *argp2;
70767   {
70768     try {
70769       (arg1)->SetDisabledSelectedImage(arg2);
70770     } catch (std::out_of_range& e) {
70771       {
70772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70773       };
70774     } catch (std::exception& e) {
70775       {
70776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70777       };
70778     } catch (Dali::DaliException e) {
70779       {
70780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70781       };
70782     } catch (...) {
70783       {
70784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70785       };
70786     }
70787   }
70788
70789 }
70790
70791
70792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70793   void * jresult ;
70794   Dali::Toolkit::RadioButton *result = 0 ;
70795
70796   {
70797     try {
70798       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70799     } catch (std::out_of_range& e) {
70800       {
70801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70802       };
70803     } catch (std::exception& e) {
70804       {
70805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70806       };
70807     } catch (Dali::DaliException e) {
70808       {
70809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70810       };
70811     } catch (...) {
70812       {
70813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70814       };
70815     }
70816   }
70817
70818   jresult = (void *)result;
70819   return jresult;
70820 }
70821
70822
70823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70824   void * jresult ;
70825   Dali::Toolkit::RadioButton *arg1 = 0 ;
70826   Dali::Toolkit::RadioButton *result = 0 ;
70827
70828   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70829   if (!arg1) {
70830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70831     return 0;
70832   }
70833   {
70834     try {
70835       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
70836     } catch (std::out_of_range& e) {
70837       {
70838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70839       };
70840     } catch (std::exception& e) {
70841       {
70842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70843       };
70844     } catch (Dali::DaliException e) {
70845       {
70846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70847       };
70848     } catch (...) {
70849       {
70850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70851       };
70852     }
70853   }
70854
70855   jresult = (void *)result;
70856   return jresult;
70857 }
70858
70859
70860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
70861   void * jresult ;
70862   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70863   Dali::Toolkit::RadioButton *arg2 = 0 ;
70864   Dali::Toolkit::RadioButton *result = 0 ;
70865
70866   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70867   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
70868   if (!arg2) {
70869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70870     return 0;
70871   }
70872   {
70873     try {
70874       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
70875     } catch (std::out_of_range& e) {
70876       {
70877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70878       };
70879     } catch (std::exception& e) {
70880       {
70881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70882       };
70883     } catch (Dali::DaliException e) {
70884       {
70885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70886       };
70887     } catch (...) {
70888       {
70889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70890       };
70891     }
70892   }
70893
70894   jresult = (void *)result;
70895   return jresult;
70896 }
70897
70898
70899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70900   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70901
70902   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70903   {
70904     try {
70905       delete arg1;
70906     } catch (std::out_of_range& e) {
70907       {
70908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70909       };
70910     } catch (std::exception& e) {
70911       {
70912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70913       };
70914     } catch (Dali::DaliException e) {
70915       {
70916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70917       };
70918     } catch (...) {
70919       {
70920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70921       };
70922     }
70923   }
70924
70925 }
70926
70927
70928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70929   void * jresult ;
70930   Dali::Toolkit::RadioButton result;
70931
70932   {
70933     try {
70934       result = Dali::Toolkit::RadioButton::New();
70935     } catch (std::out_of_range& e) {
70936       {
70937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (std::exception& e) {
70940       {
70941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70942       };
70943     } catch (Dali::DaliException e) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70950       };
70951     }
70952   }
70953
70954   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70960   void * jresult ;
70961   std::string *arg1 = 0 ;
70962   Dali::Toolkit::RadioButton result;
70963
70964   if (!jarg1) {
70965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70966     return 0;
70967   }
70968   std::string arg1_str(jarg1);
70969   arg1 = &arg1_str;
70970   {
70971     try {
70972       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70973     } catch (std::out_of_range& e) {
70974       {
70975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70976       };
70977     } catch (std::exception& e) {
70978       {
70979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70980       };
70981     } catch (Dali::DaliException e) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70984       };
70985     } catch (...) {
70986       {
70987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70988       };
70989     }
70990   }
70991
70992   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70993
70994   //argout typemap for const std::string&
70995
70996   return jresult;
70997 }
70998
70999
71000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71001   void * jresult ;
71002   Dali::BaseHandle arg1 ;
71003   Dali::BaseHandle *argp1 ;
71004   Dali::Toolkit::RadioButton result;
71005
71006   argp1 = (Dali::BaseHandle *)jarg1;
71007   if (!argp1) {
71008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71009     return 0;
71010   }
71011   arg1 = *argp1;
71012   {
71013     try {
71014       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71015     } catch (std::out_of_range& e) {
71016       {
71017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71018       };
71019     } catch (std::exception& e) {
71020       {
71021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71022       };
71023     } catch (Dali::DaliException e) {
71024       {
71025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71026       };
71027     } catch (...) {
71028       {
71029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71030       };
71031     }
71032   }
71033
71034   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71035   return jresult;
71036 }
71037
71038
71039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71040   int jresult ;
71041   int result;
71042
71043   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71044   jresult = (int)result;
71045   return jresult;
71046 }
71047
71048
71049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71050   int jresult ;
71051   int result;
71052
71053   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71054   jresult = (int)result;
71055   return jresult;
71056 }
71057
71058
71059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71060   int jresult ;
71061   int result;
71062
71063   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71064   jresult = (int)result;
71065   return jresult;
71066 }
71067
71068
71069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71070   int jresult ;
71071   int result;
71072
71073   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71074   jresult = (int)result;
71075   return jresult;
71076 }
71077
71078
71079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71080   int jresult ;
71081   int result;
71082
71083   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71084   jresult = (int)result;
71085   return jresult;
71086 }
71087
71088
71089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71090   int jresult ;
71091   int result;
71092
71093   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71094   jresult = (int)result;
71095   return jresult;
71096 }
71097
71098
71099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71100   void * jresult ;
71101   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71102
71103   {
71104     try {
71105       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71106     } catch (std::out_of_range& e) {
71107       {
71108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71109       };
71110     } catch (std::exception& e) {
71111       {
71112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71113       };
71114     } catch (Dali::DaliException e) {
71115       {
71116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71117       };
71118     } catch (...) {
71119       {
71120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71121       };
71122     }
71123   }
71124
71125   jresult = (void *)result;
71126   return jresult;
71127 }
71128
71129
71130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71131   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71132
71133   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71134   {
71135     try {
71136       delete arg1;
71137     } catch (std::out_of_range& e) {
71138       {
71139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71140       };
71141     } catch (std::exception& e) {
71142       {
71143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71144       };
71145     } catch (Dali::DaliException e) {
71146       {
71147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71148       };
71149     } catch (...) {
71150       {
71151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71152       };
71153     }
71154   }
71155
71156 }
71157
71158
71159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71160   int jresult ;
71161   int result;
71162
71163   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71164   jresult = (int)result;
71165   return jresult;
71166 }
71167
71168
71169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71170   int jresult ;
71171   int result;
71172
71173   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71174   jresult = (int)result;
71175   return jresult;
71176 }
71177
71178
71179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71180   int jresult ;
71181   int result;
71182
71183   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71184   jresult = (int)result;
71185   return jresult;
71186 }
71187
71188
71189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71190   void * jresult ;
71191   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71192
71193   {
71194     try {
71195       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71196     } catch (std::out_of_range& e) {
71197       {
71198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71199       };
71200     } catch (std::exception& e) {
71201       {
71202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71203       };
71204     } catch (Dali::DaliException e) {
71205       {
71206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71207       };
71208     } catch (...) {
71209       {
71210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71211       };
71212     }
71213   }
71214
71215   jresult = (void *)result;
71216   return jresult;
71217 }
71218
71219
71220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71221   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71222
71223   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71224   {
71225     try {
71226       delete arg1;
71227     } catch (std::out_of_range& e) {
71228       {
71229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71230       };
71231     } catch (std::exception& e) {
71232       {
71233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71234       };
71235     } catch (Dali::DaliException e) {
71236       {
71237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71238       };
71239     } catch (...) {
71240       {
71241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71242       };
71243     }
71244   }
71245
71246 }
71247
71248
71249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71250   void * jresult ;
71251   Dali::Toolkit::FlexContainer *result = 0 ;
71252
71253   {
71254     try {
71255       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71256     } catch (std::out_of_range& e) {
71257       {
71258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71259       };
71260     } catch (std::exception& e) {
71261       {
71262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71263       };
71264     } catch (Dali::DaliException e) {
71265       {
71266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71267       };
71268     } catch (...) {
71269       {
71270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71271       };
71272     }
71273   }
71274
71275   jresult = (void *)result;
71276   return jresult;
71277 }
71278
71279
71280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71281   void * jresult ;
71282   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71283   Dali::Toolkit::FlexContainer *result = 0 ;
71284
71285   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71286   if (!arg1) {
71287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71288     return 0;
71289   }
71290   {
71291     try {
71292       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71293     } catch (std::out_of_range& e) {
71294       {
71295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71296       };
71297     } catch (std::exception& e) {
71298       {
71299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71300       };
71301     } catch (Dali::DaliException e) {
71302       {
71303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71304       };
71305     } catch (...) {
71306       {
71307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71308       };
71309     }
71310   }
71311
71312   jresult = (void *)result;
71313   return jresult;
71314 }
71315
71316
71317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71318   void * jresult ;
71319   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71320   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71321   Dali::Toolkit::FlexContainer *result = 0 ;
71322
71323   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71324   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71325   if (!arg2) {
71326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71327     return 0;
71328   }
71329   {
71330     try {
71331       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71332     } catch (std::out_of_range& e) {
71333       {
71334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71335       };
71336     } catch (std::exception& e) {
71337       {
71338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71339       };
71340     } catch (Dali::DaliException e) {
71341       {
71342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71343       };
71344     } catch (...) {
71345       {
71346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71347       };
71348     }
71349   }
71350
71351   jresult = (void *)result;
71352   return jresult;
71353 }
71354
71355
71356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71357   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71358
71359   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71360   {
71361     try {
71362       delete arg1;
71363     } catch (std::out_of_range& e) {
71364       {
71365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71366       };
71367     } catch (std::exception& e) {
71368       {
71369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71370       };
71371     } catch (Dali::DaliException e) {
71372       {
71373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71374       };
71375     } catch (...) {
71376       {
71377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71378       };
71379     }
71380   }
71381
71382 }
71383
71384
71385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71386   void * jresult ;
71387   Dali::Toolkit::FlexContainer result;
71388
71389   {
71390     try {
71391       result = Dali::Toolkit::FlexContainer::New();
71392     } catch (std::out_of_range& e) {
71393       {
71394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71395       };
71396     } catch (std::exception& e) {
71397       {
71398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71399       };
71400     } catch (Dali::DaliException e) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71403       };
71404     } catch (...) {
71405       {
71406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71407       };
71408     }
71409   }
71410
71411   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71412   return jresult;
71413 }
71414
71415
71416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71417   void * jresult ;
71418   Dali::BaseHandle arg1 ;
71419   Dali::BaseHandle *argp1 ;
71420   Dali::Toolkit::FlexContainer result;
71421
71422   argp1 = (Dali::BaseHandle *)jarg1;
71423   if (!argp1) {
71424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71425     return 0;
71426   }
71427   arg1 = *argp1;
71428   {
71429     try {
71430       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71431     } catch (std::out_of_range& e) {
71432       {
71433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71434       };
71435     } catch (std::exception& e) {
71436       {
71437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71438       };
71439     } catch (Dali::DaliException e) {
71440       {
71441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71442       };
71443     } catch (...) {
71444       {
71445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71446       };
71447     }
71448   }
71449
71450   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71451   return jresult;
71452 }
71453
71454
71455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71456   int jresult ;
71457   int result;
71458
71459   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71460   jresult = (int)result;
71461   return jresult;
71462 }
71463
71464
71465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71466   int jresult ;
71467   int result;
71468
71469   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71470   jresult = (int)result;
71471   return jresult;
71472 }
71473
71474
71475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71476   int jresult ;
71477   int result;
71478
71479   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71480   jresult = (int)result;
71481   return jresult;
71482 }
71483
71484
71485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71486   int jresult ;
71487   int result;
71488
71489   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71490   jresult = (int)result;
71491   return jresult;
71492 }
71493
71494
71495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71496   void * jresult ;
71497   Dali::Toolkit::ImageView::Property *result = 0 ;
71498
71499   {
71500     try {
71501       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71502     } catch (std::out_of_range& e) {
71503       {
71504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71505       };
71506     } catch (std::exception& e) {
71507       {
71508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71509       };
71510     } catch (Dali::DaliException e) {
71511       {
71512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71513       };
71514     } catch (...) {
71515       {
71516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71517       };
71518     }
71519   }
71520
71521   jresult = (void *)result;
71522   return jresult;
71523 }
71524
71525
71526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71527   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71528
71529   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71530   {
71531     try {
71532       delete arg1;
71533     } catch (std::out_of_range& e) {
71534       {
71535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71536       };
71537     } catch (std::exception& e) {
71538       {
71539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71540       };
71541     } catch (Dali::DaliException e) {
71542       {
71543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71544       };
71545     } catch (...) {
71546       {
71547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71548       };
71549     }
71550   }
71551
71552 }
71553
71554
71555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71556   void * jresult ;
71557   Dali::Toolkit::ImageView *result = 0 ;
71558
71559   {
71560     try {
71561       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71562     } catch (std::out_of_range& e) {
71563       {
71564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71565       };
71566     } catch (std::exception& e) {
71567       {
71568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71569       };
71570     } catch (Dali::DaliException e) {
71571       {
71572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71573       };
71574     } catch (...) {
71575       {
71576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71577       };
71578     }
71579   }
71580
71581   jresult = (void *)result;
71582   return jresult;
71583 }
71584
71585
71586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71587   void * jresult ;
71588   Dali::Toolkit::ImageView result;
71589
71590   {
71591     try {
71592       result = Dali::Toolkit::ImageView::New();
71593     } catch (std::out_of_range& e) {
71594       {
71595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71596       };
71597     } catch (std::exception& e) {
71598       {
71599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71600       };
71601     } catch (Dali::DaliException e) {
71602       {
71603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71604       };
71605     } catch (...) {
71606       {
71607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71608       };
71609     }
71610   }
71611
71612   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71613   return jresult;
71614 }
71615
71616
71617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71618   void * jresult ;
71619   Dali::Image arg1 ;
71620   Dali::Image *argp1 ;
71621   Dali::Toolkit::ImageView result;
71622
71623   argp1 = (Dali::Image *)jarg1;
71624   if (!argp1) {
71625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71626     return 0;
71627   }
71628   arg1 = *argp1;
71629   {
71630     try {
71631       result = Dali::Toolkit::ImageView::New(arg1);
71632     } catch (std::out_of_range& e) {
71633       {
71634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71635       };
71636     } catch (std::exception& e) {
71637       {
71638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71639       };
71640     } catch (Dali::DaliException e) {
71641       {
71642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71643       };
71644     } catch (...) {
71645       {
71646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71647       };
71648     }
71649   }
71650
71651   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71652   return jresult;
71653 }
71654
71655
71656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71657   void * jresult ;
71658   std::string *arg1 = 0 ;
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   {
71668     try {
71669       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71670     } catch (std::out_of_range& e) {
71671       {
71672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71673       };
71674     } catch (std::exception& e) {
71675       {
71676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71677       };
71678     } catch (Dali::DaliException e) {
71679       {
71680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71681       };
71682     } catch (...) {
71683       {
71684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71685       };
71686     }
71687   }
71688
71689   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71690
71691   //argout typemap for const std::string&
71692
71693   return jresult;
71694 }
71695
71696
71697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71698   void * jresult ;
71699   std::string *arg1 = 0 ;
71700   Dali::ImageDimensions arg2 ;
71701   Dali::ImageDimensions *argp2 ;
71702   Dali::Toolkit::ImageView result;
71703
71704   if (!jarg1) {
71705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71706     return 0;
71707   }
71708   std::string arg1_str(jarg1);
71709   arg1 = &arg1_str;
71710   argp2 = (Dali::ImageDimensions *)jarg2;
71711   if (!argp2) {
71712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71713     return 0;
71714   }
71715   arg2 = *argp2;
71716   {
71717     try {
71718       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71719     } catch (std::out_of_range& e) {
71720       {
71721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71722       };
71723     } catch (std::exception& e) {
71724       {
71725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71726       };
71727     } catch (Dali::DaliException e) {
71728       {
71729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71730       };
71731     } catch (...) {
71732       {
71733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71734       };
71735     }
71736   }
71737
71738   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71739
71740   //argout typemap for const std::string&
71741
71742   return jresult;
71743 }
71744
71745
71746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71747   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71748
71749   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71750   {
71751     try {
71752       delete arg1;
71753     } catch (std::out_of_range& e) {
71754       {
71755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71756       };
71757     } catch (std::exception& e) {
71758       {
71759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71760       };
71761     } catch (Dali::DaliException e) {
71762       {
71763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71764       };
71765     } catch (...) {
71766       {
71767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71768       };
71769     }
71770   }
71771
71772 }
71773
71774
71775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71776   void * jresult ;
71777   Dali::Toolkit::ImageView *arg1 = 0 ;
71778   Dali::Toolkit::ImageView *result = 0 ;
71779
71780   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71781   if (!arg1) {
71782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71783     return 0;
71784   }
71785   {
71786     try {
71787       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71788     } catch (std::out_of_range& e) {
71789       {
71790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71791       };
71792     } catch (std::exception& e) {
71793       {
71794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71795       };
71796     } catch (Dali::DaliException e) {
71797       {
71798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71799       };
71800     } catch (...) {
71801       {
71802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71803       };
71804     }
71805   }
71806
71807   jresult = (void *)result;
71808   return jresult;
71809 }
71810
71811
71812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71813   void * jresult ;
71814   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71815   Dali::Toolkit::ImageView *arg2 = 0 ;
71816   Dali::Toolkit::ImageView *result = 0 ;
71817
71818   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71819   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71820   if (!arg2) {
71821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71822     return 0;
71823   }
71824   {
71825     try {
71826       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71827     } catch (std::out_of_range& e) {
71828       {
71829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71830       };
71831     } catch (std::exception& e) {
71832       {
71833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71834       };
71835     } catch (Dali::DaliException e) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71838       };
71839     } catch (...) {
71840       {
71841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71842       };
71843     }
71844   }
71845
71846   jresult = (void *)result;
71847   return jresult;
71848 }
71849
71850
71851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
71852   void * jresult ;
71853   Dali::BaseHandle arg1 ;
71854   Dali::BaseHandle *argp1 ;
71855   Dali::Toolkit::ImageView result;
71856
71857   argp1 = (Dali::BaseHandle *)jarg1;
71858   if (!argp1) {
71859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71860     return 0;
71861   }
71862   arg1 = *argp1;
71863   {
71864     try {
71865       result = Dali::Toolkit::ImageView::DownCast(arg1);
71866     } catch (std::out_of_range& e) {
71867       {
71868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71869       };
71870     } catch (std::exception& e) {
71871       {
71872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71873       };
71874     } catch (Dali::DaliException e) {
71875       {
71876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71877       };
71878     } catch (...) {
71879       {
71880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71881       };
71882     }
71883   }
71884
71885   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71886   return jresult;
71887 }
71888
71889
71890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
71891   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71892   Dali::Image arg2 ;
71893   Dali::Image *argp2 ;
71894
71895   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71896   argp2 = (Dali::Image *)jarg2;
71897   if (!argp2) {
71898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71899     return ;
71900   }
71901   arg2 = *argp2;
71902   {
71903     try {
71904       (arg1)->SetImage(arg2);
71905     } catch (std::out_of_range& e) {
71906       {
71907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71908       };
71909     } catch (std::exception& e) {
71910       {
71911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71912       };
71913     } catch (Dali::DaliException e) {
71914       {
71915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71916       };
71917     } catch (...) {
71918       {
71919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71920       };
71921     }
71922   }
71923
71924 }
71925
71926
71927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71928   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71929   std::string *arg2 = 0 ;
71930
71931   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71932   if (!jarg2) {
71933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71934     return ;
71935   }
71936   std::string arg2_str(jarg2);
71937   arg2 = &arg2_str;
71938   {
71939     try {
71940       (arg1)->SetImage((std::string const &)*arg2);
71941     } catch (std::out_of_range& e) {
71942       {
71943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71944       };
71945     } catch (std::exception& e) {
71946       {
71947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71948       };
71949     } catch (Dali::DaliException e) {
71950       {
71951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71952       };
71953     } catch (...) {
71954       {
71955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71956       };
71957     }
71958   }
71959
71960
71961   //argout typemap for const std::string&
71962
71963 }
71964
71965
71966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71967   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71968   std::string *arg2 = 0 ;
71969   Dali::ImageDimensions arg3 ;
71970   Dali::ImageDimensions *argp3 ;
71971
71972   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71973   if (!jarg2) {
71974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71975     return ;
71976   }
71977   std::string arg2_str(jarg2);
71978   arg2 = &arg2_str;
71979   argp3 = (Dali::ImageDimensions *)jarg3;
71980   if (!argp3) {
71981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71982     return ;
71983   }
71984   arg3 = *argp3;
71985   {
71986     try {
71987       (arg1)->SetImage((std::string const &)*arg2,arg3);
71988     } catch (std::out_of_range& e) {
71989       {
71990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71991       };
71992     } catch (std::exception& e) {
71993       {
71994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71995       };
71996     } catch (Dali::DaliException e) {
71997       {
71998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71999       };
72000     } catch (...) {
72001       {
72002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72003       };
72004     }
72005   }
72006
72007
72008   //argout typemap for const std::string&
72009
72010 }
72011
72012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72013   void * jresult ;
72014   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72015   Dali::Image result;
72016
72017   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72018   {
72019     try {
72020       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72021     } catch (std::out_of_range& e) {
72022       {
72023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72024       };
72025     } catch (std::exception& e) {
72026       {
72027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72028       };
72029     } catch (Dali::DaliException e) {
72030       {
72031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72032       };
72033     } catch (...) {
72034       {
72035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72036       };
72037     }
72038   }
72039
72040   jresult = new Dali::Image((const Dali::Image &)result);
72041   return jresult;
72042 }
72043
72044
72045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72046   int jresult ;
72047   int result;
72048
72049   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72050   jresult = (int)result;
72051   return jresult;
72052 }
72053
72054
72055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72056   int jresult ;
72057   int result;
72058
72059   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72060   jresult = (int)result;
72061   return jresult;
72062 }
72063
72064
72065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72066   int jresult ;
72067   int result;
72068
72069   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72070   jresult = (int)result;
72071   return jresult;
72072 }
72073
72074
72075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72076   int jresult ;
72077   int result;
72078
72079   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72080   jresult = (int)result;
72081   return jresult;
72082 }
72083
72084
72085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72086   int jresult ;
72087   int result;
72088
72089   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72090   jresult = (int)result;
72091   return jresult;
72092 }
72093
72094
72095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72096   int jresult ;
72097   int result;
72098
72099   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72100   jresult = (int)result;
72101   return jresult;
72102 }
72103
72104
72105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72106   int jresult ;
72107   int result;
72108
72109   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72110   jresult = (int)result;
72111   return jresult;
72112 }
72113
72114
72115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72116   int jresult ;
72117   int result;
72118
72119   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72120   jresult = (int)result;
72121   return jresult;
72122 }
72123
72124
72125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72126   void * jresult ;
72127   Dali::Toolkit::Model3dView::Property *result = 0 ;
72128
72129   {
72130     try {
72131       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72132     } catch (std::out_of_range& e) {
72133       {
72134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72135       };
72136     } catch (std::exception& e) {
72137       {
72138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72139       };
72140     } catch (Dali::DaliException e) {
72141       {
72142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72143       };
72144     } catch (...) {
72145       {
72146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72147       };
72148     }
72149   }
72150
72151   jresult = (void *)result;
72152   return jresult;
72153 }
72154
72155
72156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72157   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72158
72159   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72160   {
72161     try {
72162       delete arg1;
72163     } catch (std::out_of_range& e) {
72164       {
72165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72166       };
72167     } catch (std::exception& e) {
72168       {
72169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72170       };
72171     } catch (Dali::DaliException e) {
72172       {
72173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72174       };
72175     } catch (...) {
72176       {
72177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72178       };
72179     }
72180   }
72181
72182 }
72183
72184
72185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72186   void * jresult ;
72187   Dali::Toolkit::Model3dView result;
72188
72189   {
72190     try {
72191       result = Dali::Toolkit::Model3dView::New();
72192     } catch (std::out_of_range& e) {
72193       {
72194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72195       };
72196     } catch (std::exception& e) {
72197       {
72198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72199       };
72200     } catch (Dali::DaliException e) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72203       };
72204     } catch (...) {
72205       {
72206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72207       };
72208     }
72209   }
72210
72211   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72212   return jresult;
72213 }
72214
72215
72216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72217   void * jresult ;
72218   std::string *arg1 = 0 ;
72219   std::string *arg2 = 0 ;
72220   std::string *arg3 = 0 ;
72221   Dali::Toolkit::Model3dView result;
72222
72223   if (!jarg1) {
72224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72225     return 0;
72226   }
72227   std::string arg1_str(jarg1);
72228   arg1 = &arg1_str;
72229   if (!jarg2) {
72230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72231     return 0;
72232   }
72233   std::string arg2_str(jarg2);
72234   arg2 = &arg2_str;
72235   if (!jarg3) {
72236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72237     return 0;
72238   }
72239   std::string arg3_str(jarg3);
72240   arg3 = &arg3_str;
72241   {
72242     try {
72243       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72244     } catch (std::out_of_range& e) {
72245       {
72246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72247       };
72248     } catch (std::exception& e) {
72249       {
72250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72251       };
72252     } catch (Dali::DaliException e) {
72253       {
72254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72255       };
72256     } catch (...) {
72257       {
72258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72259       };
72260     }
72261   }
72262
72263   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72264
72265   //argout typemap for const std::string&
72266
72267
72268   //argout typemap for const std::string&
72269
72270
72271   //argout typemap for const std::string&
72272
72273   return jresult;
72274 }
72275
72276
72277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72278   void * jresult ;
72279   Dali::Toolkit::Model3dView *result = 0 ;
72280
72281   {
72282     try {
72283       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72284     } catch (std::out_of_range& e) {
72285       {
72286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72287       };
72288     } catch (std::exception& e) {
72289       {
72290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72291       };
72292     } catch (Dali::DaliException e) {
72293       {
72294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72295       };
72296     } catch (...) {
72297       {
72298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72299       };
72300     }
72301   }
72302
72303   jresult = (void *)result;
72304   return jresult;
72305 }
72306
72307
72308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72309   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72310
72311   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72312   {
72313     try {
72314       delete arg1;
72315     } catch (std::out_of_range& e) {
72316       {
72317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72318       };
72319     } catch (std::exception& e) {
72320       {
72321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72322       };
72323     } catch (Dali::DaliException e) {
72324       {
72325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72326       };
72327     } catch (...) {
72328       {
72329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72330       };
72331     }
72332   }
72333
72334 }
72335
72336
72337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72338   void * jresult ;
72339   Dali::Toolkit::Model3dView *arg1 = 0 ;
72340   Dali::Toolkit::Model3dView *result = 0 ;
72341
72342   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72343   if (!arg1) {
72344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72345     return 0;
72346   }
72347   {
72348     try {
72349       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72350     } catch (std::out_of_range& e) {
72351       {
72352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72353       };
72354     } catch (std::exception& e) {
72355       {
72356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72357       };
72358     } catch (Dali::DaliException e) {
72359       {
72360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72361       };
72362     } catch (...) {
72363       {
72364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72365       };
72366     }
72367   }
72368
72369   jresult = (void *)result;
72370   return jresult;
72371 }
72372
72373
72374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72375   void * jresult ;
72376   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72377   Dali::Toolkit::Model3dView *arg2 = 0 ;
72378   Dali::Toolkit::Model3dView *result = 0 ;
72379
72380   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72381   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72382   if (!arg2) {
72383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72384     return 0;
72385   }
72386   {
72387     try {
72388       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72389     } catch (std::out_of_range& e) {
72390       {
72391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (std::exception& e) {
72394       {
72395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72396       };
72397     } catch (Dali::DaliException e) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72400       };
72401     } catch (...) {
72402       {
72403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72404       };
72405     }
72406   }
72407
72408   jresult = (void *)result;
72409   return jresult;
72410 }
72411
72412
72413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72414   void * jresult ;
72415   Dali::BaseHandle arg1 ;
72416   Dali::BaseHandle *argp1 ;
72417   Dali::Toolkit::Model3dView result;
72418
72419   argp1 = (Dali::BaseHandle *)jarg1;
72420   if (!argp1) {
72421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72422     return 0;
72423   }
72424   arg1 = *argp1;
72425   {
72426     try {
72427       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72428     } catch (std::out_of_range& e) {
72429       {
72430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72431       };
72432     } catch (std::exception& e) {
72433       {
72434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72435       };
72436     } catch (Dali::DaliException e) {
72437       {
72438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72439       };
72440     } catch (...) {
72441       {
72442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72443       };
72444     }
72445   }
72446
72447   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72448   return jresult;
72449 }
72450
72451
72452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72453   int jresult ;
72454   int result;
72455
72456   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72457   jresult = (int)result;
72458   return jresult;
72459 }
72460
72461
72462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72463   int jresult ;
72464   int result;
72465
72466   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72467   jresult = (int)result;
72468   return jresult;
72469 }
72470
72471
72472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72473   int jresult ;
72474   int result;
72475
72476   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72477   jresult = (int)result;
72478   return jresult;
72479 }
72480
72481
72482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72483   int jresult ;
72484   int result;
72485
72486   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72487   jresult = (int)result;
72488   return jresult;
72489 }
72490
72491
72492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72493   int jresult ;
72494   int result;
72495
72496   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72497   jresult = (int)result;
72498   return jresult;
72499 }
72500
72501
72502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72503   int jresult ;
72504   int result;
72505
72506   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72507   jresult = (int)result;
72508   return jresult;
72509 }
72510
72511
72512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72513   int jresult ;
72514   int result;
72515
72516   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72517   jresult = (int)result;
72518   return jresult;
72519 }
72520
72521
72522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72523   int jresult ;
72524   int result;
72525
72526   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72527   jresult = (int)result;
72528   return jresult;
72529 }
72530
72531
72532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72533   int jresult ;
72534   int result;
72535
72536   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72537   jresult = (int)result;
72538   return jresult;
72539 }
72540
72541
72542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72543   void * jresult ;
72544   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72545
72546   {
72547     try {
72548       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72549     } catch (std::out_of_range& e) {
72550       {
72551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72552       };
72553     } catch (std::exception& e) {
72554       {
72555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72556       };
72557     } catch (Dali::DaliException e) {
72558       {
72559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72560       };
72561     } catch (...) {
72562       {
72563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72564       };
72565     }
72566   }
72567
72568   jresult = (void *)result;
72569   return jresult;
72570 }
72571
72572
72573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72574   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72575
72576   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72577   {
72578     try {
72579       delete arg1;
72580     } catch (std::out_of_range& e) {
72581       {
72582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72583       };
72584     } catch (std::exception& e) {
72585       {
72586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72587       };
72588     } catch (Dali::DaliException e) {
72589       {
72590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72591       };
72592     } catch (...) {
72593       {
72594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72595       };
72596     }
72597   }
72598
72599 }
72600
72601
72602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72603   void * jresult ;
72604   Dali::Toolkit::ScrollBar *result = 0 ;
72605
72606   {
72607     try {
72608       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72609     } catch (std::out_of_range& e) {
72610       {
72611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72612       };
72613     } catch (std::exception& e) {
72614       {
72615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72616       };
72617     } catch (Dali::DaliException e) {
72618       {
72619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72620       };
72621     } catch (...) {
72622       {
72623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72624       };
72625     }
72626   }
72627
72628   jresult = (void *)result;
72629   return jresult;
72630 }
72631
72632
72633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72634   void * jresult ;
72635   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72636   Dali::Toolkit::ScrollBar *result = 0 ;
72637
72638   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72639   if (!arg1) {
72640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72641     return 0;
72642   }
72643   {
72644     try {
72645       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72646     } catch (std::out_of_range& e) {
72647       {
72648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72649       };
72650     } catch (std::exception& e) {
72651       {
72652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72653       };
72654     } catch (Dali::DaliException e) {
72655       {
72656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72657       };
72658     } catch (...) {
72659       {
72660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72661       };
72662     }
72663   }
72664
72665   jresult = (void *)result;
72666   return jresult;
72667 }
72668
72669
72670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72671   void * jresult ;
72672   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72673   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72674   Dali::Toolkit::ScrollBar *result = 0 ;
72675
72676   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72677   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72678   if (!arg2) {
72679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72680     return 0;
72681   }
72682   {
72683     try {
72684       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72685     } catch (std::out_of_range& e) {
72686       {
72687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72688       };
72689     } catch (std::exception& e) {
72690       {
72691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72692       };
72693     } catch (Dali::DaliException e) {
72694       {
72695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72696       };
72697     } catch (...) {
72698       {
72699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72700       };
72701     }
72702   }
72703
72704   jresult = (void *)result;
72705   return jresult;
72706 }
72707
72708
72709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72710   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72711
72712   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72713   {
72714     try {
72715       delete arg1;
72716     } catch (std::out_of_range& e) {
72717       {
72718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72719       };
72720     } catch (std::exception& e) {
72721       {
72722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72723       };
72724     } catch (Dali::DaliException e) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72727       };
72728     } catch (...) {
72729       {
72730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72731       };
72732     }
72733   }
72734
72735 }
72736
72737
72738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72739   void * jresult ;
72740   Dali::Toolkit::ScrollBar::Direction arg1 ;
72741   Dali::Toolkit::ScrollBar result;
72742
72743   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72744   {
72745     try {
72746       result = Dali::Toolkit::ScrollBar::New(arg1);
72747     } catch (std::out_of_range& e) {
72748       {
72749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72750       };
72751     } catch (std::exception& e) {
72752       {
72753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72754       };
72755     } catch (Dali::DaliException e) {
72756       {
72757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72758       };
72759     } catch (...) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72762       };
72763     }
72764   }
72765
72766   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72767   return jresult;
72768 }
72769
72770
72771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72772   void * jresult ;
72773   Dali::Toolkit::ScrollBar result;
72774
72775   {
72776     try {
72777       result = Dali::Toolkit::ScrollBar::New();
72778     } catch (std::out_of_range& e) {
72779       {
72780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72781       };
72782     } catch (std::exception& e) {
72783       {
72784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72785       };
72786     } catch (Dali::DaliException e) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72789       };
72790     } catch (...) {
72791       {
72792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72793       };
72794     }
72795   }
72796
72797   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72798   return jresult;
72799 }
72800
72801
72802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72803   void * jresult ;
72804   Dali::BaseHandle arg1 ;
72805   Dali::BaseHandle *argp1 ;
72806   Dali::Toolkit::ScrollBar result;
72807
72808   argp1 = (Dali::BaseHandle *)jarg1;
72809   if (!argp1) {
72810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72811     return 0;
72812   }
72813   arg1 = *argp1;
72814   {
72815     try {
72816       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72817     } catch (std::out_of_range& e) {
72818       {
72819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72820       };
72821     } catch (std::exception& e) {
72822       {
72823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72824       };
72825     } catch (Dali::DaliException e) {
72826       {
72827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72828       };
72829     } catch (...) {
72830       {
72831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72832       };
72833     }
72834   }
72835
72836   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72837   return jresult;
72838 }
72839
72840
72841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
72842   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72843   Dali::Handle arg2 ;
72844   Dali::Property::Index arg3 ;
72845   Dali::Property::Index arg4 ;
72846   Dali::Property::Index arg5 ;
72847   Dali::Property::Index arg6 ;
72848   Dali::Handle *argp2 ;
72849
72850   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72851   argp2 = (Dali::Handle *)jarg2;
72852   if (!argp2) {
72853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
72854     return ;
72855   }
72856   arg2 = *argp2;
72857   arg3 = (Dali::Property::Index)jarg3;
72858   arg4 = (Dali::Property::Index)jarg4;
72859   arg5 = (Dali::Property::Index)jarg5;
72860   arg6 = (Dali::Property::Index)jarg6;
72861   {
72862     try {
72863       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
72864     } catch (std::out_of_range& e) {
72865       {
72866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72867       };
72868     } catch (std::exception& e) {
72869       {
72870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72871       };
72872     } catch (Dali::DaliException e) {
72873       {
72874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72875       };
72876     } catch (...) {
72877       {
72878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72879       };
72880     }
72881   }
72882
72883 }
72884
72885
72886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
72887   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72888   Dali::Actor arg2 ;
72889   Dali::Actor *argp2 ;
72890
72891   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72892   argp2 = (Dali::Actor *)jarg2;
72893   if (!argp2) {
72894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72895     return ;
72896   }
72897   arg2 = *argp2;
72898   {
72899     try {
72900       (arg1)->SetScrollIndicator(arg2);
72901     } catch (std::out_of_range& e) {
72902       {
72903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72904       };
72905     } catch (std::exception& e) {
72906       {
72907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72908       };
72909     } catch (Dali::DaliException e) {
72910       {
72911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72912       };
72913     } catch (...) {
72914       {
72915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72916       };
72917     }
72918   }
72919
72920 }
72921
72922
72923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72924   void * jresult ;
72925   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72926   Dali::Actor result;
72927
72928   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72929   {
72930     try {
72931       result = (arg1)->GetScrollIndicator();
72932     } catch (std::out_of_range& e) {
72933       {
72934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72935       };
72936     } catch (std::exception& e) {
72937       {
72938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72939       };
72940     } catch (Dali::DaliException e) {
72941       {
72942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72943       };
72944     } catch (...) {
72945       {
72946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72947       };
72948     }
72949   }
72950
72951   jresult = new Dali::Actor((const Dali::Actor &)result);
72952   return jresult;
72953 }
72954
72955
72956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72957   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72958   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72959
72960   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72961   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72962   if (!arg2) {
72963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72964     return ;
72965   }
72966   {
72967     try {
72968       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72969     } catch (std::out_of_range& e) {
72970       {
72971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72972       };
72973     } catch (std::exception& e) {
72974       {
72975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72976       };
72977     } catch (Dali::DaliException e) {
72978       {
72979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72980       };
72981     } catch (...) {
72982       {
72983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72984       };
72985     }
72986   }
72987
72988 }
72989
72990
72991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72992   void * jresult ;
72993   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72994
72995   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72996   {
72997     try {
72998       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()));
72999     } catch (std::out_of_range& e) {
73000       {
73001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73002       };
73003     } catch (std::exception& e) {
73004       {
73005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73006       };
73007     } catch (...) {
73008       {
73009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73010       };
73011     }
73012   }
73013   return jresult;
73014 }
73015
73016
73017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73018   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73019   Dali::Toolkit::ScrollBar::Direction arg2 ;
73020
73021   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73022   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73023   {
73024     try {
73025       (arg1)->SetScrollDirection(arg2);
73026     } catch (std::out_of_range& e) {
73027       {
73028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73029       };
73030     } catch (std::exception& e) {
73031       {
73032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73033       };
73034     } catch (Dali::DaliException e) {
73035       {
73036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73037       };
73038     } catch (...) {
73039       {
73040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73041       };
73042     }
73043   }
73044
73045 }
73046
73047
73048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73049   int jresult ;
73050   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73051   Dali::Toolkit::ScrollBar::Direction result;
73052
73053   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73054   {
73055     try {
73056       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73057     } catch (std::out_of_range& e) {
73058       {
73059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73060       };
73061     } catch (std::exception& e) {
73062       {
73063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73064       };
73065     } catch (Dali::DaliException e) {
73066       {
73067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73068       };
73069     } catch (...) {
73070       {
73071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73072       };
73073     }
73074   }
73075
73076   jresult = (int)result;
73077   return jresult;
73078 }
73079
73080
73081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73082   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73083   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73084
73085   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73086   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73087   {
73088     try {
73089       (arg1)->SetIndicatorHeightPolicy(arg2);
73090     } catch (std::out_of_range& e) {
73091       {
73092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73093       };
73094     } catch (std::exception& e) {
73095       {
73096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73097       };
73098     } catch (Dali::DaliException e) {
73099       {
73100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73101       };
73102     } catch (...) {
73103       {
73104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73105       };
73106     }
73107   }
73108
73109 }
73110
73111
73112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73113   int jresult ;
73114   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73115   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73116
73117   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73118   {
73119     try {
73120       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73121     } catch (std::out_of_range& e) {
73122       {
73123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73124       };
73125     } catch (std::exception& e) {
73126       {
73127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73128       };
73129     } catch (Dali::DaliException e) {
73130       {
73131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73132       };
73133     } catch (...) {
73134       {
73135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73136       };
73137     }
73138   }
73139
73140   jresult = (int)result;
73141   return jresult;
73142 }
73143
73144
73145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73146   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73147   float arg2 ;
73148
73149   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73150   arg2 = (float)jarg2;
73151   {
73152     try {
73153       (arg1)->SetIndicatorFixedHeight(arg2);
73154     } catch (std::out_of_range& e) {
73155       {
73156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73157       };
73158     } catch (std::exception& e) {
73159       {
73160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73161       };
73162     } catch (Dali::DaliException e) {
73163       {
73164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73165       };
73166     } catch (...) {
73167       {
73168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73169       };
73170     }
73171   }
73172
73173 }
73174
73175
73176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73177   float jresult ;
73178   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73179   float result;
73180
73181   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73182   {
73183     try {
73184       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73185     } catch (std::out_of_range& e) {
73186       {
73187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73188       };
73189     } catch (std::exception& e) {
73190       {
73191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73192       };
73193     } catch (Dali::DaliException e) {
73194       {
73195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73196       };
73197     } catch (...) {
73198       {
73199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73200       };
73201     }
73202   }
73203
73204   jresult = result;
73205   return jresult;
73206 }
73207
73208
73209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73210   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73211   float arg2 ;
73212
73213   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73214   arg2 = (float)jarg2;
73215   {
73216     try {
73217       (arg1)->SetIndicatorShowDuration(arg2);
73218     } catch (std::out_of_range& e) {
73219       {
73220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73221       };
73222     } catch (std::exception& e) {
73223       {
73224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73225       };
73226     } catch (Dali::DaliException e) {
73227       {
73228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73229       };
73230     } catch (...) {
73231       {
73232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73233       };
73234     }
73235   }
73236
73237 }
73238
73239
73240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73241   float jresult ;
73242   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73243   float result;
73244
73245   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73246   {
73247     try {
73248       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73249     } catch (std::out_of_range& e) {
73250       {
73251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73252       };
73253     } catch (std::exception& e) {
73254       {
73255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73256       };
73257     } catch (Dali::DaliException e) {
73258       {
73259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73260       };
73261     } catch (...) {
73262       {
73263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73264       };
73265     }
73266   }
73267
73268   jresult = result;
73269   return jresult;
73270 }
73271
73272
73273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73274   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73275   float arg2 ;
73276
73277   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73278   arg2 = (float)jarg2;
73279   {
73280     try {
73281       (arg1)->SetIndicatorHideDuration(arg2);
73282     } catch (std::out_of_range& e) {
73283       {
73284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73285       };
73286     } catch (std::exception& e) {
73287       {
73288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73289       };
73290     } catch (Dali::DaliException e) {
73291       {
73292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73293       };
73294     } catch (...) {
73295       {
73296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73297       };
73298     }
73299   }
73300
73301 }
73302
73303
73304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73305   float jresult ;
73306   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73307   float result;
73308
73309   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73310   {
73311     try {
73312       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73313     } catch (std::out_of_range& e) {
73314       {
73315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73316       };
73317     } catch (std::exception& e) {
73318       {
73319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73320       };
73321     } catch (Dali::DaliException e) {
73322       {
73323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73324       };
73325     } catch (...) {
73326       {
73327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73328       };
73329     }
73330   }
73331
73332   jresult = result;
73333   return jresult;
73334 }
73335
73336
73337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73338   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73339
73340   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73341   {
73342     try {
73343       (arg1)->ShowIndicator();
73344     } catch (std::out_of_range& e) {
73345       {
73346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73347       };
73348     } catch (std::exception& e) {
73349       {
73350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73351       };
73352     } catch (Dali::DaliException e) {
73353       {
73354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73355       };
73356     } catch (...) {
73357       {
73358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73359       };
73360     }
73361   }
73362
73363 }
73364
73365
73366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73367   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73368
73369   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73370   {
73371     try {
73372       (arg1)->HideIndicator();
73373     } catch (std::out_of_range& e) {
73374       {
73375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73376       };
73377     } catch (std::exception& e) {
73378       {
73379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73380       };
73381     } catch (Dali::DaliException e) {
73382       {
73383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73384       };
73385     } catch (...) {
73386       {
73387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73388       };
73389     }
73390   }
73391
73392 }
73393
73394
73395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73396   void * jresult ;
73397   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73398   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73399
73400   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73401   {
73402     try {
73403       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73404     } catch (std::out_of_range& e) {
73405       {
73406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73407       };
73408     } catch (std::exception& e) {
73409       {
73410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73411       };
73412     } catch (Dali::DaliException e) {
73413       {
73414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73415       };
73416     } catch (...) {
73417       {
73418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73419       };
73420     }
73421   }
73422
73423   jresult = (void *)result;
73424   return jresult;
73425 }
73426
73427
73428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73429   void * jresult ;
73430   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73431   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73432
73433   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73434   {
73435     try {
73436       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73437     } catch (std::out_of_range& e) {
73438       {
73439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73440       };
73441     } catch (std::exception& e) {
73442       {
73443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73444       };
73445     } catch (Dali::DaliException e) {
73446       {
73447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73448       };
73449     } catch (...) {
73450       {
73451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73452       };
73453     }
73454   }
73455
73456   jresult = (void *)result;
73457   return jresult;
73458 }
73459
73460
73461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73462   int jresult ;
73463   int result;
73464
73465   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73466   jresult = (int)result;
73467   return jresult;
73468 }
73469
73470
73471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73472   int jresult ;
73473   int result;
73474
73475   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73476   jresult = (int)result;
73477   return jresult;
73478 }
73479
73480
73481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73482   int jresult ;
73483   int result;
73484
73485   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73486   jresult = (int)result;
73487   return jresult;
73488 }
73489
73490
73491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73492   int jresult ;
73493   int result;
73494
73495   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73496   jresult = (int)result;
73497   return jresult;
73498 }
73499
73500
73501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73502   int jresult ;
73503   int result;
73504
73505   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73506   jresult = (int)result;
73507   return jresult;
73508 }
73509
73510
73511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73512   int jresult ;
73513   int result;
73514
73515   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73516   jresult = (int)result;
73517   return jresult;
73518 }
73519
73520
73521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73522   int jresult ;
73523   int result;
73524
73525   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73526   jresult = (int)result;
73527   return jresult;
73528 }
73529
73530
73531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73532   int jresult ;
73533   int result;
73534
73535   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73536   jresult = (int)result;
73537   return jresult;
73538 }
73539
73540
73541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73542   int jresult ;
73543   int result;
73544
73545   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73546   jresult = (int)result;
73547   return jresult;
73548 }
73549
73550
73551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73552   int jresult ;
73553   int result;
73554
73555   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73556   jresult = (int)result;
73557   return jresult;
73558 }
73559
73560
73561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73562   int jresult ;
73563   int result;
73564
73565   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73566   jresult = (int)result;
73567   return jresult;
73568 }
73569
73570
73571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73572   int jresult ;
73573   int result;
73574
73575   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73576   jresult = (int)result;
73577   return jresult;
73578 }
73579
73580
73581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73582   int jresult ;
73583   int result;
73584
73585   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73586   jresult = (int)result;
73587   return jresult;
73588 }
73589
73590
73591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73592   int jresult ;
73593   int result;
73594
73595   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73596   jresult = (int)result;
73597   return jresult;
73598 }
73599
73600
73601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73602   void * jresult ;
73603   Dali::Toolkit::Scrollable::Property *result = 0 ;
73604
73605   {
73606     try {
73607       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73608     } catch (std::out_of_range& e) {
73609       {
73610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73611       };
73612     } catch (std::exception& e) {
73613       {
73614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73615       };
73616     } catch (Dali::DaliException e) {
73617       {
73618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73619       };
73620     } catch (...) {
73621       {
73622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73623       };
73624     }
73625   }
73626
73627   jresult = (void *)result;
73628   return jresult;
73629 }
73630
73631
73632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73633   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73634
73635   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73636   {
73637     try {
73638       delete arg1;
73639     } catch (std::out_of_range& e) {
73640       {
73641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73642       };
73643     } catch (std::exception& e) {
73644       {
73645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73646       };
73647     } catch (Dali::DaliException e) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73650       };
73651     } catch (...) {
73652       {
73653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73654       };
73655     }
73656   }
73657
73658 }
73659
73660
73661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73662   void * jresult ;
73663   Dali::Toolkit::Scrollable *result = 0 ;
73664
73665   {
73666     try {
73667       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73668     } catch (std::out_of_range& e) {
73669       {
73670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73671       };
73672     } catch (std::exception& e) {
73673       {
73674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73675       };
73676     } catch (Dali::DaliException e) {
73677       {
73678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73679       };
73680     } catch (...) {
73681       {
73682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73683       };
73684     }
73685   }
73686
73687   jresult = (void *)result;
73688   return jresult;
73689 }
73690
73691
73692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73693   void * jresult ;
73694   Dali::Toolkit::Scrollable *arg1 = 0 ;
73695   Dali::Toolkit::Scrollable *result = 0 ;
73696
73697   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73698   if (!arg1) {
73699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73700     return 0;
73701   }
73702   {
73703     try {
73704       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73705     } catch (std::out_of_range& e) {
73706       {
73707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73708       };
73709     } catch (std::exception& e) {
73710       {
73711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73712       };
73713     } catch (Dali::DaliException e) {
73714       {
73715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73716       };
73717     } catch (...) {
73718       {
73719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73720       };
73721     }
73722   }
73723
73724   jresult = (void *)result;
73725   return jresult;
73726 }
73727
73728
73729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73730   void * jresult ;
73731   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73732   Dali::Toolkit::Scrollable *arg2 = 0 ;
73733   Dali::Toolkit::Scrollable *result = 0 ;
73734
73735   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73736   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73737   if (!arg2) {
73738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73739     return 0;
73740   }
73741   {
73742     try {
73743       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73744     } catch (std::out_of_range& e) {
73745       {
73746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73747       };
73748     } catch (std::exception& e) {
73749       {
73750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73751       };
73752     } catch (Dali::DaliException e) {
73753       {
73754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73755       };
73756     } catch (...) {
73757       {
73758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73759       };
73760     }
73761   }
73762
73763   jresult = (void *)result;
73764   return jresult;
73765 }
73766
73767
73768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73769   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73770
73771   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73772   {
73773     try {
73774       delete arg1;
73775     } catch (std::out_of_range& e) {
73776       {
73777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73778       };
73779     } catch (std::exception& e) {
73780       {
73781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73782       };
73783     } catch (Dali::DaliException e) {
73784       {
73785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73786       };
73787     } catch (...) {
73788       {
73789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73790       };
73791     }
73792   }
73793
73794 }
73795
73796
73797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73798   void * jresult ;
73799   Dali::BaseHandle arg1 ;
73800   Dali::BaseHandle *argp1 ;
73801   Dali::Toolkit::Scrollable result;
73802
73803   argp1 = (Dali::BaseHandle *)jarg1;
73804   if (!argp1) {
73805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73806     return 0;
73807   }
73808   arg1 = *argp1;
73809   {
73810     try {
73811       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73812     } catch (std::out_of_range& e) {
73813       {
73814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73815       };
73816     } catch (std::exception& e) {
73817       {
73818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73819       };
73820     } catch (Dali::DaliException e) {
73821       {
73822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73823       };
73824     } catch (...) {
73825       {
73826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73827       };
73828     }
73829   }
73830
73831   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73832   return jresult;
73833 }
73834
73835
73836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
73837   unsigned int jresult ;
73838   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73839   bool result;
73840
73841   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73842   {
73843     try {
73844       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
73845     } catch (std::out_of_range& e) {
73846       {
73847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73848       };
73849     } catch (std::exception& e) {
73850       {
73851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73852       };
73853     } catch (Dali::DaliException e) {
73854       {
73855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73856       };
73857     } catch (...) {
73858       {
73859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73860       };
73861     }
73862   }
73863
73864   jresult = result;
73865   return jresult;
73866 }
73867
73868
73869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
73870   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73871   bool arg2 ;
73872
73873   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73874   arg2 = jarg2 ? true : false;
73875   {
73876     try {
73877       (arg1)->SetOvershootEnabled(arg2);
73878     } catch (std::out_of_range& e) {
73879       {
73880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73881       };
73882     } catch (std::exception& e) {
73883       {
73884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73885       };
73886     } catch (Dali::DaliException e) {
73887       {
73888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73889       };
73890     } catch (...) {
73891       {
73892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73893       };
73894     }
73895   }
73896
73897 }
73898
73899
73900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73901   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73902   Dali::Vector4 *arg2 = 0 ;
73903
73904   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73905   arg2 = (Dali::Vector4 *)jarg2;
73906   if (!arg2) {
73907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73908     return ;
73909   }
73910   {
73911     try {
73912       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73913     } catch (std::out_of_range& e) {
73914       {
73915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73916       };
73917     } catch (std::exception& e) {
73918       {
73919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73920       };
73921     } catch (Dali::DaliException e) {
73922       {
73923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73924       };
73925     } catch (...) {
73926       {
73927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73928       };
73929     }
73930   }
73931
73932 }
73933
73934
73935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73936   void * jresult ;
73937   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73938   Dali::Vector4 result;
73939
73940   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73941   {
73942     try {
73943       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73944     } catch (std::out_of_range& e) {
73945       {
73946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73947       };
73948     } catch (std::exception& e) {
73949       {
73950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73951       };
73952     } catch (Dali::DaliException e) {
73953       {
73954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73955       };
73956     } catch (...) {
73957       {
73958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73959       };
73960     }
73961   }
73962
73963   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73964   return jresult;
73965 }
73966
73967
73968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73969   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73970   float arg2 ;
73971
73972   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73973   arg2 = (float)jarg2;
73974   {
73975     try {
73976       (arg1)->SetOvershootAnimationSpeed(arg2);
73977     } catch (std::out_of_range& e) {
73978       {
73979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73980       };
73981     } catch (std::exception& e) {
73982       {
73983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73984       };
73985     } catch (Dali::DaliException e) {
73986       {
73987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73988       };
73989     } catch (...) {
73990       {
73991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73992       };
73993     }
73994   }
73995
73996 }
73997
73998
73999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74000   float jresult ;
74001   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74002   float result;
74003
74004   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74005   {
74006     try {
74007       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74008     } catch (std::out_of_range& e) {
74009       {
74010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74011       };
74012     } catch (std::exception& e) {
74013       {
74014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74015       };
74016     } catch (Dali::DaliException e) {
74017       {
74018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74019       };
74020     } catch (...) {
74021       {
74022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74023       };
74024     }
74025   }
74026
74027   jresult = result;
74028   return jresult;
74029 }
74030
74031
74032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74033   void * jresult ;
74034   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74035   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74036
74037   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74038   {
74039     try {
74040       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74041     } catch (std::out_of_range& e) {
74042       {
74043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74044       };
74045     } catch (std::exception& e) {
74046       {
74047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74048       };
74049     } catch (Dali::DaliException e) {
74050       {
74051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74052       };
74053     } catch (...) {
74054       {
74055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74056       };
74057     }
74058   }
74059
74060   jresult = (void *)result;
74061   return jresult;
74062 }
74063
74064
74065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74066   void * jresult ;
74067   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74068   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74069
74070   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74071   {
74072     try {
74073       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74074     } catch (std::out_of_range& e) {
74075       {
74076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74077       };
74078     } catch (std::exception& e) {
74079       {
74080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74081       };
74082     } catch (Dali::DaliException e) {
74083       {
74084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74085       };
74086     } catch (...) {
74087       {
74088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74089       };
74090     }
74091   }
74092
74093   jresult = (void *)result;
74094   return jresult;
74095 }
74096
74097
74098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74099   void * jresult ;
74100   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74101   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74102
74103   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74104   {
74105     try {
74106       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74107     } catch (std::out_of_range& e) {
74108       {
74109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74110       };
74111     } catch (std::exception& e) {
74112       {
74113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74114       };
74115     } catch (Dali::DaliException e) {
74116       {
74117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74118       };
74119     } catch (...) {
74120       {
74121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74122       };
74123     }
74124   }
74125
74126   jresult = (void *)result;
74127   return jresult;
74128 }
74129
74130
74131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74132   unsigned int jresult ;
74133   Dali::Toolkit::ControlOrientation::Type arg1 ;
74134   bool result;
74135
74136   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74137   {
74138     try {
74139       result = (bool)Dali::Toolkit::IsVertical(arg1);
74140     } catch (std::out_of_range& e) {
74141       {
74142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74143       };
74144     } catch (std::exception& e) {
74145       {
74146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74147       };
74148     } catch (Dali::DaliException e) {
74149       {
74150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74151       };
74152     } catch (...) {
74153       {
74154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74155       };
74156     }
74157   }
74158
74159   jresult = result;
74160   return jresult;
74161 }
74162
74163
74164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74165   unsigned int jresult ;
74166   Dali::Toolkit::ControlOrientation::Type arg1 ;
74167   bool result;
74168
74169   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74170   {
74171     try {
74172       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74173     } catch (std::out_of_range& e) {
74174       {
74175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74176       };
74177     } catch (std::exception& e) {
74178       {
74179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74180       };
74181     } catch (Dali::DaliException e) {
74182       {
74183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74184       };
74185     } catch (...) {
74186       {
74187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74188       };
74189     }
74190   }
74191
74192   jresult = result;
74193   return jresult;
74194 }
74195
74196
74197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74198   void * jresult ;
74199   unsigned int arg1 ;
74200   unsigned int arg2 ;
74201   Dali::Toolkit::ItemRange *result = 0 ;
74202
74203   arg1 = (unsigned int)jarg1;
74204   arg2 = (unsigned int)jarg2;
74205   {
74206     try {
74207       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74208     } catch (std::out_of_range& e) {
74209       {
74210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74211       };
74212     } catch (std::exception& e) {
74213       {
74214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74215       };
74216     } catch (Dali::DaliException e) {
74217       {
74218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74219       };
74220     } catch (...) {
74221       {
74222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74223       };
74224     }
74225   }
74226
74227   jresult = (void *)result;
74228   return jresult;
74229 }
74230
74231
74232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74233   void * jresult ;
74234   Dali::Toolkit::ItemRange *arg1 = 0 ;
74235   Dali::Toolkit::ItemRange *result = 0 ;
74236
74237   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74238   if (!arg1) {
74239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74240     return 0;
74241   }
74242   {
74243     try {
74244       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74245     } catch (std::out_of_range& e) {
74246       {
74247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74248       };
74249     } catch (std::exception& e) {
74250       {
74251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74252       };
74253     } catch (Dali::DaliException e) {
74254       {
74255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74256       };
74257     } catch (...) {
74258       {
74259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74260       };
74261     }
74262   }
74263
74264   jresult = (void *)result;
74265   return jresult;
74266 }
74267
74268
74269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74270   void * jresult ;
74271   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74272   Dali::Toolkit::ItemRange *arg2 = 0 ;
74273   Dali::Toolkit::ItemRange *result = 0 ;
74274
74275   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74276   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74277   if (!arg2) {
74278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74279     return 0;
74280   }
74281   {
74282     try {
74283       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74284     } catch (std::out_of_range& e) {
74285       {
74286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74287       };
74288     } catch (std::exception& e) {
74289       {
74290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74291       };
74292     } catch (Dali::DaliException e) {
74293       {
74294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74295       };
74296     } catch (...) {
74297       {
74298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74299       };
74300     }
74301   }
74302
74303   jresult = (void *)result;
74304   return jresult;
74305 }
74306
74307
74308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74309   unsigned int jresult ;
74310   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74311   unsigned int arg2 ;
74312   bool result;
74313
74314   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74315   arg2 = (unsigned int)jarg2;
74316   {
74317     try {
74318       result = (bool)(arg1)->Within(arg2);
74319     } catch (std::out_of_range& e) {
74320       {
74321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74322       };
74323     } catch (std::exception& e) {
74324       {
74325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74326       };
74327     } catch (Dali::DaliException e) {
74328       {
74329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74330       };
74331     } catch (...) {
74332       {
74333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74334       };
74335     }
74336   }
74337
74338   jresult = result;
74339   return jresult;
74340 }
74341
74342
74343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74344   void * jresult ;
74345   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74346   Dali::Toolkit::ItemRange *arg2 = 0 ;
74347   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74348
74349   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74350   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74351   if (!arg2) {
74352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74353     return 0;
74354   }
74355   {
74356     try {
74357       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74358     } catch (std::out_of_range& e) {
74359       {
74360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74361       };
74362     } catch (std::exception& e) {
74363       {
74364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74365       };
74366     } catch (Dali::DaliException e) {
74367       {
74368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74369       };
74370     } catch (...) {
74371       {
74372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74373       };
74374     }
74375   }
74376
74377   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74378   return jresult;
74379 }
74380
74381
74382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74383   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74384   unsigned int arg2 ;
74385
74386   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74387   arg2 = (unsigned int)jarg2;
74388   if (arg1) (arg1)->begin = arg2;
74389 }
74390
74391
74392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74393   unsigned int jresult ;
74394   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74395   unsigned int result;
74396
74397   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74398   result = (unsigned int) ((arg1)->begin);
74399   jresult = result;
74400   return jresult;
74401 }
74402
74403
74404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74405   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74406   unsigned int arg2 ;
74407
74408   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74409   arg2 = (unsigned int)jarg2;
74410   if (arg1) (arg1)->end = arg2;
74411 }
74412
74413
74414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74415   unsigned int jresult ;
74416   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74417   unsigned int result;
74418
74419   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74420   result = (unsigned int) ((arg1)->end);
74421   jresult = result;
74422   return jresult;
74423 }
74424
74425
74426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74427   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74428
74429   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74430   {
74431     try {
74432       delete arg1;
74433     } catch (std::out_of_range& e) {
74434       {
74435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74436       };
74437     } catch (std::exception& e) {
74438       {
74439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74440       };
74441     } catch (Dali::DaliException e) {
74442       {
74443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74444       };
74445     } catch (...) {
74446       {
74447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74448       };
74449     }
74450   }
74451
74452 }
74453
74454
74455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74456   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74457
74458   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74459   {
74460     try {
74461       delete arg1;
74462     } catch (std::out_of_range& e) {
74463       {
74464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74465       };
74466     } catch (std::exception& e) {
74467       {
74468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74469       };
74470     } catch (Dali::DaliException e) {
74471       {
74472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74473       };
74474     } catch (...) {
74475       {
74476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74477       };
74478     }
74479   }
74480
74481 }
74482
74483
74484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74485   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74486   Dali::Toolkit::ControlOrientation::Type arg2 ;
74487
74488   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74489   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74490   {
74491     try {
74492       (arg1)->SetOrientation(arg2);
74493     } catch (std::out_of_range& e) {
74494       {
74495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74496       };
74497     } catch (std::exception& e) {
74498       {
74499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74500       };
74501     } catch (Dali::DaliException e) {
74502       {
74503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74504       };
74505     } catch (...) {
74506       {
74507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74508       };
74509     }
74510   }
74511
74512 }
74513
74514
74515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74516   int jresult ;
74517   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74518   Dali::Toolkit::ControlOrientation::Type result;
74519
74520   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74521   {
74522     try {
74523       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74524     } catch (std::out_of_range& e) {
74525       {
74526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74527       };
74528     } catch (std::exception& e) {
74529       {
74530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74531       };
74532     } catch (Dali::DaliException e) {
74533       {
74534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74535       };
74536     } catch (...) {
74537       {
74538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74539       };
74540     }
74541   }
74542
74543   jresult = (int)result;
74544   return jresult;
74545 }
74546
74547
74548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74549   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74550   Dali::Property::Map *arg2 = 0 ;
74551
74552   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74553   arg2 = (Dali::Property::Map *)jarg2;
74554   if (!arg2) {
74555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74556     return ;
74557   }
74558   {
74559     try {
74560       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74561     } catch (std::out_of_range& e) {
74562       {
74563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74564       };
74565     } catch (std::exception& e) {
74566       {
74567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74568       };
74569     } catch (Dali::DaliException e) {
74570       {
74571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74572       };
74573     } catch (...) {
74574       {
74575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74576       };
74577     }
74578   }
74579
74580 }
74581
74582
74583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74584   void * jresult ;
74585   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74586   Dali::Property::Map result;
74587
74588   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74589   {
74590     try {
74591       result = (arg1)->GetLayoutProperties();
74592     } catch (std::out_of_range& e) {
74593       {
74594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74595       };
74596     } catch (std::exception& e) {
74597       {
74598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74599       };
74600     } catch (Dali::DaliException e) {
74601       {
74602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74603       };
74604     } catch (...) {
74605       {
74606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74607       };
74608     }
74609   }
74610
74611   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74612   return jresult;
74613 }
74614
74615
74616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74617   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74618   unsigned int arg2 ;
74619   Dali::Vector3 *arg3 = 0 ;
74620   Dali::Vector3 *arg4 = 0 ;
74621
74622   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74623   arg2 = (unsigned int)jarg2;
74624   arg3 = (Dali::Vector3 *)jarg3;
74625   if (!arg3) {
74626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74627     return ;
74628   }
74629   arg4 = (Dali::Vector3 *)jarg4;
74630   if (!arg4) {
74631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74632     return ;
74633   }
74634   {
74635     try {
74636       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74637     } catch (std::out_of_range& e) {
74638       {
74639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74640       };
74641     } catch (std::exception& e) {
74642       {
74643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74644       };
74645     } catch (Dali::DaliException e) {
74646       {
74647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74648       };
74649     } catch (...) {
74650       {
74651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74652       };
74653     }
74654   }
74655
74656 }
74657
74658
74659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74660   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74661   Dali::Vector3 *arg2 = 0 ;
74662
74663   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74664   arg2 = (Dali::Vector3 *)jarg2;
74665   if (!arg2) {
74666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74667     return ;
74668   }
74669   {
74670     try {
74671       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74672     } catch (std::out_of_range& e) {
74673       {
74674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74675       };
74676     } catch (std::exception& e) {
74677       {
74678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74679       };
74680     } catch (Dali::DaliException e) {
74681       {
74682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74683       };
74684     } catch (...) {
74685       {
74686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74687       };
74688     }
74689   }
74690
74691 }
74692
74693
74694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74695   float jresult ;
74696   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74697   unsigned int arg2 ;
74698   Dali::Vector3 arg3 ;
74699   Dali::Vector3 *argp3 ;
74700   float result;
74701
74702   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74703   arg2 = (unsigned int)jarg2;
74704   argp3 = (Dali::Vector3 *)jarg3;
74705   if (!argp3) {
74706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74707     return 0;
74708   }
74709   arg3 = *argp3;
74710   {
74711     try {
74712       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74713     } catch (std::out_of_range& e) {
74714       {
74715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74716       };
74717     } catch (std::exception& e) {
74718       {
74719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74720       };
74721     } catch (Dali::DaliException e) {
74722       {
74723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74724       };
74725     } catch (...) {
74726       {
74727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74728       };
74729     }
74730   }
74731
74732   jresult = result;
74733   return jresult;
74734 }
74735
74736
74737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74738   float jresult ;
74739   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74740   float arg2 ;
74741   float result;
74742
74743   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74744   arg2 = (float)jarg2;
74745   {
74746     try {
74747       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74748     } catch (std::out_of_range& e) {
74749       {
74750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74751       };
74752     } catch (std::exception& e) {
74753       {
74754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74755       };
74756     } catch (Dali::DaliException e) {
74757       {
74758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74759       };
74760     } catch (...) {
74761       {
74762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74763       };
74764     }
74765   }
74766
74767   jresult = result;
74768   return jresult;
74769 }
74770
74771
74772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74773   float jresult ;
74774   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74775   unsigned int arg2 ;
74776   float result;
74777
74778   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74779   arg2 = (unsigned int)jarg2;
74780   {
74781     try {
74782       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
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 = result;
74803   return jresult;
74804 }
74805
74806
74807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74808   void * jresult ;
74809   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74810   float arg2 ;
74811   Dali::Vector3 arg3 ;
74812   Dali::Vector3 *argp3 ;
74813   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74814
74815   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74816   arg2 = (float)jarg2;
74817   argp3 = (Dali::Vector3 *)jarg3;
74818   if (!argp3) {
74819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74820     return 0;
74821   }
74822   arg3 = *argp3;
74823   {
74824     try {
74825       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
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 = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74846   return jresult;
74847 }
74848
74849
74850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74851   float jresult ;
74852   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74853   int arg2 ;
74854   float arg3 ;
74855   Dali::Vector3 *arg4 = 0 ;
74856   float result;
74857
74858   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74859   arg2 = (int)jarg2;
74860   arg3 = (float)jarg3;
74861   arg4 = (Dali::Vector3 *)jarg4;
74862   if (!arg4) {
74863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74864     return 0;
74865   }
74866   {
74867     try {
74868       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74869     } catch (std::out_of_range& e) {
74870       {
74871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74872       };
74873     } catch (std::exception& e) {
74874       {
74875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74876       };
74877     } catch (Dali::DaliException e) {
74878       {
74879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74880       };
74881     } catch (...) {
74882       {
74883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74884       };
74885     }
74886   }
74887
74888   jresult = result;
74889   return jresult;
74890 }
74891
74892
74893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74894   unsigned int jresult ;
74895   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74896   Dali::Vector3 arg2 ;
74897   Dali::Vector3 *argp2 ;
74898   unsigned int result;
74899
74900   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74901   argp2 = (Dali::Vector3 *)jarg2;
74902   if (!argp2) {
74903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74904     return 0;
74905   }
74906   arg2 = *argp2;
74907   {
74908     try {
74909       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74910     } catch (std::out_of_range& e) {
74911       {
74912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74913       };
74914     } catch (std::exception& e) {
74915       {
74916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74917       };
74918     } catch (Dali::DaliException e) {
74919       {
74920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74921       };
74922     } catch (...) {
74923       {
74924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74925       };
74926     }
74927   }
74928
74929   jresult = result;
74930   return jresult;
74931 }
74932
74933
74934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74935   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74936   unsigned int arg2 ;
74937   Dali::Vector3 *arg3 = 0 ;
74938   Dali::Vector3 *arg4 = 0 ;
74939
74940   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74941   arg2 = (unsigned int)jarg2;
74942   arg3 = (Dali::Vector3 *)jarg3;
74943   if (!arg3) {
74944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74945     return ;
74946   }
74947   arg4 = (Dali::Vector3 *)jarg4;
74948   if (!arg4) {
74949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74950     return ;
74951   }
74952   {
74953     try {
74954       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74955     } catch (std::out_of_range& e) {
74956       {
74957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74958       };
74959     } catch (std::exception& e) {
74960       {
74961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74962       };
74963     } catch (Dali::DaliException e) {
74964       {
74965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74966       };
74967     } catch (...) {
74968       {
74969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74970       };
74971     }
74972   }
74973
74974 }
74975
74976
74977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74978   void * jresult ;
74979   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74980   Dali::Degree result;
74981
74982   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74983   {
74984     try {
74985       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74986     } catch (std::out_of_range& e) {
74987       {
74988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74989       };
74990     } catch (std::exception& e) {
74991       {
74992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74993       };
74994     } catch (Dali::DaliException e) {
74995       {
74996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74997       };
74998     } catch (...) {
74999       {
75000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75001       };
75002     }
75003   }
75004
75005   jresult = new Dali::Degree((const Dali::Degree &)result);
75006   return jresult;
75007 }
75008
75009
75010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75011   float jresult ;
75012   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75013   float result;
75014
75015   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75016   {
75017     try {
75018       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75019     } catch (std::out_of_range& e) {
75020       {
75021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75022       };
75023     } catch (std::exception& e) {
75024       {
75025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75026       };
75027     } catch (Dali::DaliException e) {
75028       {
75029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75030       };
75031     } catch (...) {
75032       {
75033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75034       };
75035     }
75036   }
75037
75038   jresult = result;
75039   return jresult;
75040 }
75041
75042
75043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75044   float jresult ;
75045   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75046   float result;
75047
75048   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75049   {
75050     try {
75051       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75052     } catch (std::out_of_range& e) {
75053       {
75054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75055       };
75056     } catch (std::exception& e) {
75057       {
75058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75059       };
75060     } catch (Dali::DaliException e) {
75061       {
75062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75063       };
75064     } catch (...) {
75065       {
75066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75067       };
75068     }
75069   }
75070
75071   jresult = result;
75072   return jresult;
75073 }
75074
75075
75076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75077   float jresult ;
75078   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75079   float result;
75080
75081   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75082   {
75083     try {
75084       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75085     } catch (std::out_of_range& e) {
75086       {
75087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75088       };
75089     } catch (std::exception& e) {
75090       {
75091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75092       };
75093     } catch (Dali::DaliException e) {
75094       {
75095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75096       };
75097     } catch (...) {
75098       {
75099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75100       };
75101     }
75102   }
75103
75104   jresult = result;
75105   return jresult;
75106 }
75107
75108
75109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75110   int jresult ;
75111   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75112   int arg2 ;
75113   int arg3 ;
75114   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75115   bool arg5 ;
75116   int result;
75117
75118   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75119   arg2 = (int)jarg2;
75120   arg3 = (int)jarg3;
75121   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75122   arg5 = jarg5 ? true : false;
75123   {
75124     try {
75125       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75126     } catch (std::out_of_range& e) {
75127       {
75128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75129       };
75130     } catch (std::exception& e) {
75131       {
75132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75133       };
75134     } catch (Dali::DaliException e) {
75135       {
75136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75137       };
75138     } catch (...) {
75139       {
75140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75141       };
75142     }
75143   }
75144
75145   jresult = result;
75146   return jresult;
75147 }
75148
75149
75150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75151   float jresult ;
75152   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75153   float result;
75154
75155   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75156   {
75157     try {
75158       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75159     } catch (std::out_of_range& e) {
75160       {
75161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75162       };
75163     } catch (std::exception& e) {
75164       {
75165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75166       };
75167     } catch (Dali::DaliException e) {
75168       {
75169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75170       };
75171     } catch (...) {
75172       {
75173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75174       };
75175     }
75176   }
75177
75178   jresult = result;
75179   return jresult;
75180 }
75181
75182
75183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75184   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75185   Dali::Actor *arg2 = 0 ;
75186   int arg3 ;
75187   Dali::Vector3 *arg4 = 0 ;
75188   Dali::Actor *arg5 = 0 ;
75189
75190   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75191   arg2 = (Dali::Actor *)jarg2;
75192   if (!arg2) {
75193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75194     return ;
75195   }
75196   arg3 = (int)jarg3;
75197   arg4 = (Dali::Vector3 *)jarg4;
75198   if (!arg4) {
75199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75200     return ;
75201   }
75202   arg5 = (Dali::Actor *)jarg5;
75203   if (!arg5) {
75204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75205     return ;
75206   }
75207   {
75208     try {
75209       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75210     } catch (std::out_of_range& e) {
75211       {
75212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75213       };
75214     } catch (std::exception& e) {
75215       {
75216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75217       };
75218     } catch (Dali::DaliException e) {
75219       {
75220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75221       };
75222     } catch (...) {
75223       {
75224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75225       };
75226     }
75227   }
75228
75229 }
75230
75231
75232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75233   void * jresult ;
75234   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75235   int arg2 ;
75236   float arg3 ;
75237   Dali::Vector3 *arg4 = 0 ;
75238   Dali::Vector3 result;
75239
75240   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75241   arg2 = (int)jarg2;
75242   arg3 = (float)jarg3;
75243   arg4 = (Dali::Vector3 *)jarg4;
75244   if (!arg4) {
75245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75246     return 0;
75247   }
75248   {
75249     try {
75250       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75251     } catch (std::out_of_range& e) {
75252       {
75253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75254       };
75255     } catch (std::exception& e) {
75256       {
75257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75258       };
75259     } catch (Dali::DaliException e) {
75260       {
75261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75262       };
75263     } catch (...) {
75264       {
75265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75266       };
75267     }
75268   }
75269
75270   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75271   return jresult;
75272 }
75273
75274
75275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75276   void * jresult ;
75277   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75278   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75279
75280   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75281   {
75282     try {
75283       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75284     } catch (std::out_of_range& e) {
75285       {
75286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75287       };
75288     } catch (std::exception& e) {
75289       {
75290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75291       };
75292     } catch (Dali::DaliException e) {
75293       {
75294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75295       };
75296     } catch (...) {
75297       {
75298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75299       };
75300     }
75301   }
75302
75303   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75304   return jresult;
75305 }
75306
75307
75308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75309   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75310
75311   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75312   {
75313     try {
75314       delete arg1;
75315     } catch (std::out_of_range& e) {
75316       {
75317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75318       };
75319     } catch (std::exception& e) {
75320       {
75321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75322       };
75323     } catch (Dali::DaliException e) {
75324       {
75325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75326       };
75327     } catch (...) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75330       };
75331     }
75332   }
75333
75334 }
75335
75336
75337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75338   unsigned int jresult ;
75339   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75340   unsigned int result;
75341
75342   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75343   {
75344     try {
75345       result = (unsigned int)(arg1)->GetNumberOfItems();
75346     } catch (std::out_of_range& e) {
75347       {
75348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75349       };
75350     } catch (std::exception& e) {
75351       {
75352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75353       };
75354     } catch (Dali::DaliException e) {
75355       {
75356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75357       };
75358     } catch (...) {
75359       {
75360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75361       };
75362     }
75363   }
75364
75365   jresult = result;
75366   return jresult;
75367 }
75368
75369
75370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75371   void * jresult ;
75372   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75373   unsigned int arg2 ;
75374   Dali::Actor result;
75375
75376   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75377   arg2 = (unsigned int)jarg2;
75378   {
75379     try {
75380       result = (arg1)->NewItem(arg2);
75381     } catch (std::out_of_range& e) {
75382       {
75383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75384       };
75385     } catch (std::exception& e) {
75386       {
75387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75388       };
75389     } catch (Dali::DaliException e) {
75390       {
75391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75392       };
75393     } catch (...) {
75394       {
75395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75396       };
75397     }
75398   }
75399
75400   jresult = new Dali::Actor((const Dali::Actor &)result);
75401   return jresult;
75402 }
75403
75404
75405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75406   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75407   unsigned int arg2 ;
75408   Dali::Actor arg3 ;
75409   Dali::Actor *argp3 ;
75410
75411   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75412   arg2 = (unsigned int)jarg2;
75413   argp3 = (Dali::Actor *)jarg3;
75414   if (!argp3) {
75415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75416     return ;
75417   }
75418   arg3 = *argp3;
75419   {
75420     try {
75421       (arg1)->ItemReleased(arg2,arg3);
75422     } catch (std::out_of_range& e) {
75423       {
75424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75425       };
75426     } catch (std::exception& e) {
75427       {
75428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75429       };
75430     } catch (Dali::DaliException e) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75433       };
75434     } catch (...) {
75435       {
75436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75437       };
75438     }
75439   }
75440
75441 }
75442
75443
75444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75445   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75446   unsigned int arg2 ;
75447   Dali::Actor arg3 ;
75448   Dali::Actor *argp3 ;
75449
75450   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75451   arg2 = (unsigned int)jarg2;
75452   argp3 = (Dali::Actor *)jarg3;
75453   if (!argp3) {
75454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75455     return ;
75456   }
75457   arg3 = *argp3;
75458   {
75459     try {
75460       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75461     } catch (std::out_of_range& e) {
75462       {
75463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75464       };
75465     } catch (std::exception& e) {
75466       {
75467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75468       };
75469     } catch (Dali::DaliException e) {
75470       {
75471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75472       };
75473     } catch (...) {
75474       {
75475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75476       };
75477     }
75478   }
75479
75480 }
75481
75482
75483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75484   void * jresult ;
75485   Dali::Toolkit::ItemFactory *result = 0 ;
75486
75487   {
75488     try {
75489       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75490     } catch (std::out_of_range& e) {
75491       {
75492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75493       };
75494     } catch (std::exception& e) {
75495       {
75496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75497       };
75498     } catch (Dali::DaliException e) {
75499       {
75500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75501       };
75502     } catch (...) {
75503       {
75504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75505       };
75506     }
75507   }
75508
75509   jresult = (void *)result;
75510   return jresult;
75511 }
75512
75513
75514 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) {
75515   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75516   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75517   if (director) {
75518     director->swig_connect_director(callback0, callback1, callback2);
75519   }
75520 }
75521
75522
75523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75524   int jresult ;
75525   int result;
75526
75527   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75528   jresult = (int)result;
75529   return jresult;
75530 }
75531
75532
75533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75534   int jresult ;
75535   int result;
75536
75537   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75538   jresult = (int)result;
75539   return jresult;
75540 }
75541
75542
75543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75544   int jresult ;
75545   int result;
75546
75547   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75548   jresult = (int)result;
75549   return jresult;
75550 }
75551
75552
75553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75554   int jresult ;
75555   int result;
75556
75557   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75558   jresult = (int)result;
75559   return jresult;
75560 }
75561
75562
75563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75564   int jresult ;
75565   int result;
75566
75567   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75568   jresult = (int)result;
75569   return jresult;
75570 }
75571
75572
75573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75574   int jresult ;
75575   int result;
75576
75577   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75578   jresult = (int)result;
75579   return jresult;
75580 }
75581
75582
75583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75584   int jresult ;
75585   int result;
75586
75587   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75588   jresult = (int)result;
75589   return jresult;
75590 }
75591
75592
75593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75594   int jresult ;
75595   int result;
75596
75597   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75598   jresult = (int)result;
75599   return jresult;
75600 }
75601
75602
75603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75604   int jresult ;
75605   int result;
75606
75607   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75608   jresult = (int)result;
75609   return jresult;
75610 }
75611
75612
75613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75614   int jresult ;
75615   int result;
75616
75617   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75618   jresult = (int)result;
75619   return jresult;
75620 }
75621
75622
75623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75624   int jresult ;
75625   int result;
75626
75627   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75628   jresult = (int)result;
75629   return jresult;
75630 }
75631
75632
75633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75634   void * jresult ;
75635   Dali::Toolkit::ItemView::Property *result = 0 ;
75636
75637   {
75638     try {
75639       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75640     } catch (std::out_of_range& e) {
75641       {
75642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75643       };
75644     } catch (std::exception& e) {
75645       {
75646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75647       };
75648     } catch (Dali::DaliException e) {
75649       {
75650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75651       };
75652     } catch (...) {
75653       {
75654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75655       };
75656     }
75657   }
75658
75659   jresult = (void *)result;
75660   return jresult;
75661 }
75662
75663
75664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75665   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75666
75667   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75668   {
75669     try {
75670       delete arg1;
75671     } catch (std::out_of_range& e) {
75672       {
75673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75674       };
75675     } catch (std::exception& e) {
75676       {
75677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75678       };
75679     } catch (Dali::DaliException e) {
75680       {
75681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75682       };
75683     } catch (...) {
75684       {
75685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75686       };
75687     }
75688   }
75689
75690 }
75691
75692
75693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75694   void * jresult ;
75695   Dali::Toolkit::ItemView *result = 0 ;
75696
75697   {
75698     try {
75699       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75700     } catch (std::out_of_range& e) {
75701       {
75702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75703       };
75704     } catch (std::exception& e) {
75705       {
75706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75707       };
75708     } catch (Dali::DaliException e) {
75709       {
75710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75711       };
75712     } catch (...) {
75713       {
75714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75715       };
75716     }
75717   }
75718
75719   jresult = (void *)result;
75720   return jresult;
75721 }
75722
75723
75724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75725   void * jresult ;
75726   Dali::Toolkit::ItemView *arg1 = 0 ;
75727   Dali::Toolkit::ItemView *result = 0 ;
75728
75729   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75730   if (!arg1) {
75731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75732     return 0;
75733   }
75734   {
75735     try {
75736       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75737     } catch (std::out_of_range& e) {
75738       {
75739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75740       };
75741     } catch (std::exception& e) {
75742       {
75743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75744       };
75745     } catch (Dali::DaliException e) {
75746       {
75747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75748       };
75749     } catch (...) {
75750       {
75751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75752       };
75753     }
75754   }
75755
75756   jresult = (void *)result;
75757   return jresult;
75758 }
75759
75760
75761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75762   void * jresult ;
75763   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75764   Dali::Toolkit::ItemView *arg2 = 0 ;
75765   Dali::Toolkit::ItemView *result = 0 ;
75766
75767   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75768   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75769   if (!arg2) {
75770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75771     return 0;
75772   }
75773   {
75774     try {
75775       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75776     } catch (std::out_of_range& e) {
75777       {
75778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75779       };
75780     } catch (std::exception& e) {
75781       {
75782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75783       };
75784     } catch (Dali::DaliException e) {
75785       {
75786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75787       };
75788     } catch (...) {
75789       {
75790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75791       };
75792     }
75793   }
75794
75795   jresult = (void *)result;
75796   return jresult;
75797 }
75798
75799
75800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75801   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75802
75803   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75804   {
75805     try {
75806       delete arg1;
75807     } catch (std::out_of_range& e) {
75808       {
75809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75810       };
75811     } catch (std::exception& e) {
75812       {
75813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75814       };
75815     } catch (Dali::DaliException e) {
75816       {
75817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75818       };
75819     } catch (...) {
75820       {
75821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75822       };
75823     }
75824   }
75825
75826 }
75827
75828
75829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75830   void * jresult ;
75831   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75832   Dali::Toolkit::ItemView result;
75833
75834   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75835   if (!arg1) {
75836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
75837     return 0;
75838   }
75839   {
75840     try {
75841       result = Dali::Toolkit::ItemView::New(*arg1);
75842     } catch (std::out_of_range& e) {
75843       {
75844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75845       };
75846     } catch (std::exception& e) {
75847       {
75848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75849       };
75850     } catch (Dali::DaliException e) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75853       };
75854     } catch (...) {
75855       {
75856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75857       };
75858     }
75859   }
75860
75861   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75862   return jresult;
75863 }
75864
75865
75866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
75867   void * jresult ;
75868   Dali::BaseHandle arg1 ;
75869   Dali::BaseHandle *argp1 ;
75870   Dali::Toolkit::ItemView result;
75871
75872   argp1 = (Dali::BaseHandle *)jarg1;
75873   if (!argp1) {
75874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75875     return 0;
75876   }
75877   arg1 = *argp1;
75878   {
75879     try {
75880       result = Dali::Toolkit::ItemView::DownCast(arg1);
75881     } catch (std::out_of_range& e) {
75882       {
75883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75884       };
75885     } catch (std::exception& e) {
75886       {
75887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75888       };
75889     } catch (Dali::DaliException e) {
75890       {
75891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75892       };
75893     } catch (...) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75896       };
75897     }
75898   }
75899
75900   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75901   return jresult;
75902 }
75903
75904
75905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75906   unsigned int jresult ;
75907   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75908   unsigned int result;
75909
75910   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75911   {
75912     try {
75913       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75914     } catch (std::out_of_range& e) {
75915       {
75916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75917       };
75918     } catch (std::exception& e) {
75919       {
75920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75921       };
75922     } catch (Dali::DaliException e) {
75923       {
75924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75925       };
75926     } catch (...) {
75927       {
75928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75929       };
75930     }
75931   }
75932
75933   jresult = result;
75934   return jresult;
75935 }
75936
75937
75938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75939   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75940   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75941
75942   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75943   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75944   if (!arg2) {
75945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75946     return ;
75947   }
75948   {
75949     try {
75950       (arg1)->AddLayout(*arg2);
75951     } catch (std::out_of_range& e) {
75952       {
75953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75954       };
75955     } catch (std::exception& e) {
75956       {
75957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75958       };
75959     } catch (Dali::DaliException e) {
75960       {
75961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75962       };
75963     } catch (...) {
75964       {
75965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75966       };
75967     }
75968   }
75969
75970 }
75971
75972
75973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75974   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75975   unsigned int arg2 ;
75976
75977   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75978   arg2 = (unsigned int)jarg2;
75979   {
75980     try {
75981       (arg1)->RemoveLayout(arg2);
75982     } catch (std::out_of_range& e) {
75983       {
75984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75985       };
75986     } catch (std::exception& e) {
75987       {
75988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75989       };
75990     } catch (Dali::DaliException e) {
75991       {
75992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75993       };
75994     } catch (...) {
75995       {
75996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75997       };
75998     }
75999   }
76000
76001 }
76002
76003
76004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76005   void * jresult ;
76006   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76007   unsigned int arg2 ;
76008   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76009
76010   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76011   arg2 = (unsigned int)jarg2;
76012   {
76013     try {
76014       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76015     } catch (std::out_of_range& e) {
76016       {
76017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76018       };
76019     } catch (std::exception& e) {
76020       {
76021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76022       };
76023     } catch (Dali::DaliException e) {
76024       {
76025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76026       };
76027     } catch (...) {
76028       {
76029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76030       };
76031     }
76032   }
76033
76034   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76035   return jresult;
76036 }
76037
76038
76039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76040   void * jresult ;
76041   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76042   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76043
76044   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76045   {
76046     try {
76047       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76048     } catch (std::out_of_range& e) {
76049       {
76050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76051       };
76052     } catch (std::exception& e) {
76053       {
76054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76055       };
76056     } catch (Dali::DaliException e) {
76057       {
76058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76059       };
76060     } catch (...) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76063       };
76064     }
76065   }
76066
76067   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76068   return jresult;
76069 }
76070
76071
76072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76073   float jresult ;
76074   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76075   Dali::Toolkit::ItemId arg2 ;
76076   float result;
76077
76078   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76079   arg2 = (Dali::Toolkit::ItemId)jarg2;
76080   {
76081     try {
76082       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76083     } catch (std::out_of_range& e) {
76084       {
76085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76086       };
76087     } catch (std::exception& e) {
76088       {
76089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76090       };
76091     } catch (Dali::DaliException e) {
76092       {
76093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76094       };
76095     } catch (...) {
76096       {
76097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76098       };
76099     }
76100   }
76101
76102   jresult = result;
76103   return jresult;
76104 }
76105
76106
76107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76108   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76109   unsigned int arg2 ;
76110   Dali::Vector3 arg3 ;
76111   float arg4 ;
76112   Dali::Vector3 *argp3 ;
76113
76114   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76115   arg2 = (unsigned int)jarg2;
76116   argp3 = (Dali::Vector3 *)jarg3;
76117   if (!argp3) {
76118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76119     return ;
76120   }
76121   arg3 = *argp3;
76122   arg4 = (float)jarg4;
76123   {
76124     try {
76125       (arg1)->ActivateLayout(arg2,arg3,arg4);
76126     } catch (std::out_of_range& e) {
76127       {
76128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76129       };
76130     } catch (std::exception& e) {
76131       {
76132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76133       };
76134     } catch (Dali::DaliException e) {
76135       {
76136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76137       };
76138     } catch (...) {
76139       {
76140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76141       };
76142     }
76143   }
76144
76145 }
76146
76147
76148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76149   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76150
76151   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76152   {
76153     try {
76154       (arg1)->DeactivateCurrentLayout();
76155     } catch (std::out_of_range& e) {
76156       {
76157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76158       };
76159     } catch (std::exception& e) {
76160       {
76161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76162       };
76163     } catch (Dali::DaliException e) {
76164       {
76165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76166       };
76167     } catch (...) {
76168       {
76169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76170       };
76171     }
76172   }
76173
76174 }
76175
76176
76177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76178   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76179   float arg2 ;
76180
76181   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76182   arg2 = (float)jarg2;
76183   {
76184     try {
76185       (arg1)->SetMinimumSwipeSpeed(arg2);
76186     } catch (std::out_of_range& e) {
76187       {
76188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76189       };
76190     } catch (std::exception& e) {
76191       {
76192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76193       };
76194     } catch (Dali::DaliException e) {
76195       {
76196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76197       };
76198     } catch (...) {
76199       {
76200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76201       };
76202     }
76203   }
76204
76205 }
76206
76207
76208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76209   float jresult ;
76210   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76211   float result;
76212
76213   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76214   {
76215     try {
76216       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76217     } catch (std::out_of_range& e) {
76218       {
76219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76220       };
76221     } catch (std::exception& e) {
76222       {
76223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76224       };
76225     } catch (Dali::DaliException e) {
76226       {
76227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76228       };
76229     } catch (...) {
76230       {
76231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76232       };
76233     }
76234   }
76235
76236   jresult = result;
76237   return jresult;
76238 }
76239
76240
76241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76242   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76243   float arg2 ;
76244
76245   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76246   arg2 = (float)jarg2;
76247   {
76248     try {
76249       (arg1)->SetMinimumSwipeDistance(arg2);
76250     } catch (std::out_of_range& e) {
76251       {
76252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76253       };
76254     } catch (std::exception& e) {
76255       {
76256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76257       };
76258     } catch (Dali::DaliException e) {
76259       {
76260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76261       };
76262     } catch (...) {
76263       {
76264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76265       };
76266     }
76267   }
76268
76269 }
76270
76271
76272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76273   float jresult ;
76274   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76275   float result;
76276
76277   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76278   {
76279     try {
76280       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76281     } catch (std::out_of_range& e) {
76282       {
76283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76284       };
76285     } catch (std::exception& e) {
76286       {
76287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76288       };
76289     } catch (Dali::DaliException e) {
76290       {
76291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76292       };
76293     } catch (...) {
76294       {
76295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76296       };
76297     }
76298   }
76299
76300   jresult = result;
76301   return jresult;
76302 }
76303
76304
76305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76306   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76307   float arg2 ;
76308
76309   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76310   arg2 = (float)jarg2;
76311   {
76312     try {
76313       (arg1)->SetWheelScrollDistanceStep(arg2);
76314     } catch (std::out_of_range& e) {
76315       {
76316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76317       };
76318     } catch (std::exception& e) {
76319       {
76320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76321       };
76322     } catch (Dali::DaliException e) {
76323       {
76324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76325       };
76326     } catch (...) {
76327       {
76328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76329       };
76330     }
76331   }
76332
76333 }
76334
76335
76336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76337   float jresult ;
76338   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76339   float result;
76340
76341   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76342   {
76343     try {
76344       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76345     } catch (std::out_of_range& e) {
76346       {
76347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76348       };
76349     } catch (std::exception& e) {
76350       {
76351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76352       };
76353     } catch (Dali::DaliException e) {
76354       {
76355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76356       };
76357     } catch (...) {
76358       {
76359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76360       };
76361     }
76362   }
76363
76364   jresult = result;
76365   return jresult;
76366 }
76367
76368
76369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76370   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76371   bool arg2 ;
76372
76373   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76374   arg2 = jarg2 ? true : false;
76375   {
76376     try {
76377       (arg1)->SetAnchoring(arg2);
76378     } catch (std::out_of_range& e) {
76379       {
76380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76381       };
76382     } catch (std::exception& e) {
76383       {
76384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76385       };
76386     } catch (Dali::DaliException e) {
76387       {
76388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76389       };
76390     } catch (...) {
76391       {
76392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76393       };
76394     }
76395   }
76396
76397 }
76398
76399 //// ========================= end of part 3 =============================
76400
76401 //// ========================== start part 4 ===============================
76402
76403
76404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76405   unsigned int jresult ;
76406   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76407   bool result;
76408
76409   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76410   {
76411     try {
76412       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76413     } catch (std::out_of_range& e) {
76414       {
76415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76416       };
76417     } catch (std::exception& e) {
76418       {
76419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76420       };
76421     } catch (Dali::DaliException e) {
76422       {
76423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76424       };
76425     } catch (...) {
76426       {
76427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76428       };
76429     }
76430   }
76431
76432   jresult = result;
76433   return jresult;
76434 }
76435
76436
76437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76439   float arg2 ;
76440
76441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76442   arg2 = (float)jarg2;
76443   {
76444     try {
76445       (arg1)->SetAnchoringDuration(arg2);
76446     } catch (std::out_of_range& e) {
76447       {
76448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76449       };
76450     } catch (std::exception& e) {
76451       {
76452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76453       };
76454     } catch (Dali::DaliException e) {
76455       {
76456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76457       };
76458     } catch (...) {
76459       {
76460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76461       };
76462     }
76463   }
76464
76465 }
76466
76467
76468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76469   float jresult ;
76470   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76471   float result;
76472
76473   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76474   {
76475     try {
76476       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76477     } catch (std::out_of_range& e) {
76478       {
76479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76480       };
76481     } catch (std::exception& e) {
76482       {
76483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76484       };
76485     } catch (Dali::DaliException e) {
76486       {
76487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76488       };
76489     } catch (...) {
76490       {
76491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76492       };
76493     }
76494   }
76495
76496   jresult = result;
76497   return jresult;
76498 }
76499
76500
76501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76502   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76503   Dali::Toolkit::ItemId arg2 ;
76504   float arg3 ;
76505
76506   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76507   arg2 = (Dali::Toolkit::ItemId)jarg2;
76508   arg3 = (float)jarg3;
76509   {
76510     try {
76511       (arg1)->ScrollToItem(arg2,arg3);
76512     } catch (std::out_of_range& e) {
76513       {
76514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76515       };
76516     } catch (std::exception& e) {
76517       {
76518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76519       };
76520     } catch (Dali::DaliException e) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76523       };
76524     } catch (...) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76527       };
76528     }
76529   }
76530
76531 }
76532
76533
76534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76535   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76536   float arg2 ;
76537
76538   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76539   arg2 = (float)jarg2;
76540   {
76541     try {
76542       (arg1)->SetRefreshInterval(arg2);
76543     } catch (std::out_of_range& e) {
76544       {
76545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76546       };
76547     } catch (std::exception& e) {
76548       {
76549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76550       };
76551     } catch (Dali::DaliException e) {
76552       {
76553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76554       };
76555     } catch (...) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76558       };
76559     }
76560   }
76561
76562 }
76563
76564
76565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76566   float jresult ;
76567   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76568   float result;
76569
76570   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76571   {
76572     try {
76573       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76574     } catch (std::out_of_range& e) {
76575       {
76576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76577       };
76578     } catch (std::exception& e) {
76579       {
76580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76581       };
76582     } catch (Dali::DaliException e) {
76583       {
76584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76585       };
76586     } catch (...) {
76587       {
76588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76589       };
76590     }
76591   }
76592
76593   jresult = result;
76594   return jresult;
76595 }
76596
76597
76598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76599   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76600
76601   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76602   {
76603     try {
76604       (arg1)->Refresh();
76605     } catch (std::out_of_range& e) {
76606       {
76607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76608       };
76609     } catch (std::exception& e) {
76610       {
76611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76612       };
76613     } catch (Dali::DaliException e) {
76614       {
76615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76616       };
76617     } catch (...) {
76618       {
76619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76620       };
76621     }
76622   }
76623
76624 }
76625
76626
76627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76628   void * jresult ;
76629   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76630   Dali::Toolkit::ItemId arg2 ;
76631   Dali::Actor result;
76632
76633   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76634   arg2 = (Dali::Toolkit::ItemId)jarg2;
76635   {
76636     try {
76637       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76638     } catch (std::out_of_range& e) {
76639       {
76640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76641       };
76642     } catch (std::exception& e) {
76643       {
76644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76645       };
76646     } catch (Dali::DaliException e) {
76647       {
76648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76649       };
76650     } catch (...) {
76651       {
76652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76653       };
76654     }
76655   }
76656
76657   jresult = new Dali::Actor((const Dali::Actor &)result);
76658   return jresult;
76659 }
76660
76661
76662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76663   unsigned int jresult ;
76664   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76665   Dali::Actor arg2 ;
76666   Dali::Actor *argp2 ;
76667   Dali::Toolkit::ItemId result;
76668
76669   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76670   argp2 = (Dali::Actor *)jarg2;
76671   if (!argp2) {
76672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76673     return 0;
76674   }
76675   arg2 = *argp2;
76676   {
76677     try {
76678       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76679     } catch (std::out_of_range& e) {
76680       {
76681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76682       };
76683     } catch (std::exception& e) {
76684       {
76685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76686       };
76687     } catch (Dali::DaliException e) {
76688       {
76689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76690       };
76691     } catch (...) {
76692       {
76693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76694       };
76695     }
76696   }
76697
76698   jresult = result;
76699   return jresult;
76700 }
76701
76702
76703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76704   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76705   Dali::Toolkit::Item arg2 ;
76706   float arg3 ;
76707   Dali::Toolkit::Item *argp2 ;
76708
76709   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76710   argp2 = (Dali::Toolkit::Item *)jarg2;
76711   if (!argp2) {
76712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76713     return ;
76714   }
76715   arg2 = *argp2;
76716   arg3 = (float)jarg3;
76717   {
76718     try {
76719       (arg1)->InsertItem(arg2,arg3);
76720     } catch (std::out_of_range& e) {
76721       {
76722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76723       };
76724     } catch (std::exception& e) {
76725       {
76726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76727       };
76728     } catch (Dali::DaliException e) {
76729       {
76730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76731       };
76732     } catch (...) {
76733       {
76734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76735       };
76736     }
76737   }
76738
76739 }
76740
76741
76742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76743   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76744   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76745   float arg3 ;
76746
76747   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76748   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76749   if (!arg2) {
76750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76751     return ;
76752   }
76753   arg3 = (float)jarg3;
76754   {
76755     try {
76756       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76757     } catch (std::out_of_range& e) {
76758       {
76759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76760       };
76761     } catch (std::exception& e) {
76762       {
76763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76764       };
76765     } catch (Dali::DaliException e) {
76766       {
76767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76768       };
76769     } catch (...) {
76770       {
76771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76772       };
76773     }
76774   }
76775
76776 }
76777
76778
76779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76780   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76781   Dali::Toolkit::ItemId arg2 ;
76782   float arg3 ;
76783
76784   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76785   arg2 = (Dali::Toolkit::ItemId)jarg2;
76786   arg3 = (float)jarg3;
76787   {
76788     try {
76789       (arg1)->RemoveItem(arg2,arg3);
76790     } catch (std::out_of_range& e) {
76791       {
76792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76793       };
76794     } catch (std::exception& e) {
76795       {
76796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76797       };
76798     } catch (Dali::DaliException e) {
76799       {
76800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76801       };
76802     } catch (...) {
76803       {
76804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76805       };
76806     }
76807   }
76808
76809 }
76810
76811
76812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76813   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76814   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76815   float arg3 ;
76816
76817   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76818   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76819   if (!arg2) {
76820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76821     return ;
76822   }
76823   arg3 = (float)jarg3;
76824   {
76825     try {
76826       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76827     } catch (std::out_of_range& e) {
76828       {
76829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76830       };
76831     } catch (std::exception& e) {
76832       {
76833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76834       };
76835     } catch (Dali::DaliException e) {
76836       {
76837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76838       };
76839     } catch (...) {
76840       {
76841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76842       };
76843     }
76844   }
76845
76846 }
76847
76848
76849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
76850   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76851   Dali::Toolkit::Item arg2 ;
76852   float arg3 ;
76853   Dali::Toolkit::Item *argp2 ;
76854
76855   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76856   argp2 = (Dali::Toolkit::Item *)jarg2;
76857   if (!argp2) {
76858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76859     return ;
76860   }
76861   arg2 = *argp2;
76862   arg3 = (float)jarg3;
76863   {
76864     try {
76865       (arg1)->ReplaceItem(arg2,arg3);
76866     } catch (std::out_of_range& e) {
76867       {
76868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76869       };
76870     } catch (std::exception& e) {
76871       {
76872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76873       };
76874     } catch (Dali::DaliException e) {
76875       {
76876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76877       };
76878     } catch (...) {
76879       {
76880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76881       };
76882     }
76883   }
76884
76885 }
76886
76887
76888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
76889   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76890   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76891   float arg3 ;
76892
76893   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76894   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76895   if (!arg2) {
76896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76897     return ;
76898   }
76899   arg3 = (float)jarg3;
76900   {
76901     try {
76902       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76903     } catch (std::out_of_range& e) {
76904       {
76905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76906       };
76907     } catch (std::exception& e) {
76908       {
76909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76910       };
76911     } catch (Dali::DaliException e) {
76912       {
76913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76914       };
76915     } catch (...) {
76916       {
76917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76918       };
76919     }
76920   }
76921
76922 }
76923
76924
76925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76926   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76927   Dali::Vector3 *arg2 = 0 ;
76928
76929   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76930   arg2 = (Dali::Vector3 *)jarg2;
76931   if (!arg2) {
76932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76933     return ;
76934   }
76935   {
76936     try {
76937       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76938     } catch (std::out_of_range& e) {
76939       {
76940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76941       };
76942     } catch (std::exception& e) {
76943       {
76944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76945       };
76946     } catch (Dali::DaliException e) {
76947       {
76948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76949       };
76950     } catch (...) {
76951       {
76952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76953       };
76954     }
76955   }
76956
76957 }
76958
76959
76960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76961   void * jresult ;
76962   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76963   Dali::Vector3 result;
76964
76965   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76966   {
76967     try {
76968       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76969     } catch (std::out_of_range& e) {
76970       {
76971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76972       };
76973     } catch (std::exception& e) {
76974       {
76975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76976       };
76977     } catch (Dali::DaliException e) {
76978       {
76979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76980       };
76981     } catch (...) {
76982       {
76983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76984       };
76985     }
76986   }
76987
76988   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76989   return jresult;
76990 }
76991
76992
76993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76994   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76995   Dali::Vector3 *arg2 = 0 ;
76996
76997   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76998   arg2 = (Dali::Vector3 *)jarg2;
76999   if (!arg2) {
77000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77001     return ;
77002   }
77003   {
77004     try {
77005       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77006     } catch (std::out_of_range& e) {
77007       {
77008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77009       };
77010     } catch (std::exception& e) {
77011       {
77012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77013       };
77014     } catch (Dali::DaliException e) {
77015       {
77016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77017       };
77018     } catch (...) {
77019       {
77020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77021       };
77022     }
77023   }
77024
77025 }
77026
77027
77028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77029   void * jresult ;
77030   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77031   Dali::Vector3 result;
77032
77033   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77034   {
77035     try {
77036       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77037     } catch (std::out_of_range& e) {
77038       {
77039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77040       };
77041     } catch (std::exception& e) {
77042       {
77043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77044       };
77045     } catch (Dali::DaliException e) {
77046       {
77047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77048       };
77049     } catch (...) {
77050       {
77051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77052       };
77053     }
77054   }
77055
77056   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77057   return jresult;
77058 }
77059
77060
77061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77062   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77063   Dali::Toolkit::ItemRange *arg2 = 0 ;
77064
77065   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77066   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77067   if (!arg2) {
77068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77069     return ;
77070   }
77071   {
77072     try {
77073       (arg1)->GetItemsRange(*arg2);
77074     } catch (std::out_of_range& e) {
77075       {
77076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77077       };
77078     } catch (std::exception& e) {
77079       {
77080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77081       };
77082     } catch (Dali::DaliException e) {
77083       {
77084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77085       };
77086     } catch (...) {
77087       {
77088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77089       };
77090     }
77091   }
77092
77093 }
77094
77095
77096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77097   void * jresult ;
77098   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77099   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77100
77101   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77102   {
77103     try {
77104       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77105     } catch (std::out_of_range& e) {
77106       {
77107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77108       };
77109     } catch (std::exception& e) {
77110       {
77111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77112       };
77113     } catch (Dali::DaliException e) {
77114       {
77115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77116       };
77117     } catch (...) {
77118       {
77119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77120       };
77121     }
77122   }
77123
77124   jresult = (void *)result;
77125   return jresult;
77126 }
77127
77128
77129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77130   Dali::Vector3 *arg1 = 0 ;
77131   PropertyInputContainer *arg2 = 0 ;
77132
77133   arg1 = (Dali::Vector3 *)jarg1;
77134   if (!arg1) {
77135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77136     return ;
77137   }
77138   arg2 = (PropertyInputContainer *)jarg2;
77139   if (!arg2) {
77140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77141     return ;
77142   }
77143   {
77144     try {
77145       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77146     } catch (std::out_of_range& e) {
77147       {
77148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77149       };
77150     } catch (std::exception& e) {
77151       {
77152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77153       };
77154     } catch (Dali::DaliException e) {
77155       {
77156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77157       };
77158     } catch (...) {
77159       {
77160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77161       };
77162     }
77163   }
77164
77165 }
77166
77167
77168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77169   Dali::Vector3 *arg1 = 0 ;
77170   PropertyInputContainer *arg2 = 0 ;
77171
77172   arg1 = (Dali::Vector3 *)jarg1;
77173   if (!arg1) {
77174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77175     return ;
77176   }
77177   arg2 = (PropertyInputContainer *)jarg2;
77178   if (!arg2) {
77179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77180     return ;
77181   }
77182   {
77183     try {
77184       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77185     } catch (std::out_of_range& e) {
77186       {
77187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77188       };
77189     } catch (std::exception& e) {
77190       {
77191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77192       };
77193     } catch (Dali::DaliException e) {
77194       {
77195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77196       };
77197     } catch (...) {
77198       {
77199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77200       };
77201     }
77202   }
77203
77204 }
77205
77206
77207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77208   void * jresult ;
77209   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77210
77211   {
77212     try {
77213       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77214     } catch (std::out_of_range& e) {
77215       {
77216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77217       };
77218     } catch (std::exception& e) {
77219       {
77220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77221       };
77222     } catch (Dali::DaliException e) {
77223       {
77224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77225       };
77226     } catch (...) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77229       };
77230     }
77231   }
77232
77233   jresult = (void *)result;
77234   return jresult;
77235 }
77236
77237
77238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77239   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77240
77241   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77242   {
77243     try {
77244       delete arg1;
77245     } catch (std::out_of_range& e) {
77246       {
77247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77248       };
77249     } catch (std::exception& e) {
77250       {
77251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77252       };
77253     } catch (Dali::DaliException e) {
77254       {
77255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77256       };
77257     } catch (...) {
77258       {
77259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77260       };
77261     }
77262   }
77263
77264 }
77265
77266
77267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77268   void * jresult ;
77269   Dali::Path arg1 ;
77270   Dali::Vector3 *arg2 = 0 ;
77271   Dali::Property::Index arg3 ;
77272   Dali::Vector3 *arg4 = 0 ;
77273   unsigned int arg5 ;
77274   Dali::Path *argp1 ;
77275   Dali::Toolkit::ScrollViewPagePathEffect result;
77276
77277   argp1 = (Dali::Path *)jarg1;
77278   if (!argp1) {
77279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77280     return 0;
77281   }
77282   arg1 = *argp1;
77283   arg2 = (Dali::Vector3 *)jarg2;
77284   if (!arg2) {
77285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77286     return 0;
77287   }
77288   arg3 = (Dali::Property::Index)jarg3;
77289   arg4 = (Dali::Vector3 *)jarg4;
77290   if (!arg4) {
77291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77292     return 0;
77293   }
77294   arg5 = (unsigned int)jarg5;
77295   {
77296     try {
77297       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77298     } catch (std::out_of_range& e) {
77299       {
77300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77301       };
77302     } catch (std::exception& e) {
77303       {
77304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77305       };
77306     } catch (Dali::DaliException e) {
77307       {
77308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77309       };
77310     } catch (...) {
77311       {
77312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77313       };
77314     }
77315   }
77316
77317   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77318   return jresult;
77319 }
77320
77321
77322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77323   void * jresult ;
77324   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77325
77326   {
77327     try {
77328       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77329     } catch (std::out_of_range& e) {
77330       {
77331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77332       };
77333     } catch (std::exception& e) {
77334       {
77335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77336       };
77337     } catch (Dali::DaliException e) {
77338       {
77339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77340       };
77341     } catch (...) {
77342       {
77343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77344       };
77345     }
77346   }
77347
77348   jresult = (void *)result;
77349   return jresult;
77350 }
77351
77352
77353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77354   void * jresult ;
77355   Dali::BaseHandle arg1 ;
77356   Dali::BaseHandle *argp1 ;
77357   Dali::Toolkit::ScrollViewPagePathEffect result;
77358
77359   argp1 = (Dali::BaseHandle *)jarg1;
77360   if (!argp1) {
77361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77362     return 0;
77363   }
77364   arg1 = *argp1;
77365   {
77366     try {
77367       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77368     } catch (std::out_of_range& e) {
77369       {
77370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77371       };
77372     } catch (std::exception& e) {
77373       {
77374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77375       };
77376     } catch (Dali::DaliException e) {
77377       {
77378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77379       };
77380     } catch (...) {
77381       {
77382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77383       };
77384     }
77385   }
77386
77387   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77388   return jresult;
77389 }
77390
77391
77392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77393   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77394   Dali::Actor arg2 ;
77395   unsigned int arg3 ;
77396   Dali::Actor *argp2 ;
77397
77398   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77399   argp2 = (Dali::Actor *)jarg2;
77400   if (!argp2) {
77401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77402     return ;
77403   }
77404   arg2 = *argp2;
77405   arg3 = (unsigned int)jarg3;
77406   {
77407     try {
77408       (arg1)->ApplyToPage(arg2,arg3);
77409     } catch (std::out_of_range& e) {
77410       {
77411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77412       };
77413     } catch (std::exception& e) {
77414       {
77415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77416       };
77417     } catch (Dali::DaliException e) {
77418       {
77419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77420       };
77421     } catch (...) {
77422       {
77423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77424       };
77425     }
77426   }
77427
77428 }
77429
77430
77431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77432   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77433
77434   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77435   {
77436     try {
77437       delete arg1;
77438     } catch (std::out_of_range& e) {
77439       {
77440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77441       };
77442     } catch (std::exception& e) {
77443       {
77444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77445       };
77446     } catch (Dali::DaliException e) {
77447       {
77448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77449       };
77450     } catch (...) {
77451       {
77452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77453       };
77454     }
77455   }
77456
77457 }
77458
77459
77460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77461   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77462   Dali::Toolkit::ClampState arg2 ;
77463
77464   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77465   arg2 = (Dali::Toolkit::ClampState)jarg2;
77466   if (arg1) (arg1)->x = arg2;
77467 }
77468
77469
77470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77471   int jresult ;
77472   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77473   Dali::Toolkit::ClampState result;
77474
77475   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77476   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77477   jresult = (int)result;
77478   return jresult;
77479 }
77480
77481
77482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77483   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77484   Dali::Toolkit::ClampState arg2 ;
77485
77486   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77487   arg2 = (Dali::Toolkit::ClampState)jarg2;
77488   if (arg1) (arg1)->y = arg2;
77489 }
77490
77491
77492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77493   int jresult ;
77494   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77495   Dali::Toolkit::ClampState result;
77496
77497   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77498   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77499   jresult = (int)result;
77500   return jresult;
77501 }
77502
77503
77504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77505   void * jresult ;
77506   Dali::Toolkit::ClampState2D *result = 0 ;
77507
77508   {
77509     try {
77510       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77511     } catch (std::out_of_range& e) {
77512       {
77513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77514       };
77515     } catch (std::exception& e) {
77516       {
77517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77518       };
77519     } catch (Dali::DaliException e) {
77520       {
77521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77522       };
77523     } catch (...) {
77524       {
77525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77526       };
77527     }
77528   }
77529
77530   jresult = (void *)result;
77531   return jresult;
77532 }
77533
77534
77535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77536   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77537
77538   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77539   {
77540     try {
77541       delete arg1;
77542     } catch (std::out_of_range& e) {
77543       {
77544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77545       };
77546     } catch (std::exception& e) {
77547       {
77548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77549       };
77550     } catch (Dali::DaliException e) {
77551       {
77552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77553       };
77554     } catch (...) {
77555       {
77556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77557       };
77558     }
77559   }
77560
77561 }
77562
77563
77564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77565   void * jresult ;
77566   float arg1 ;
77567   float arg2 ;
77568   bool arg3 ;
77569   Dali::Toolkit::RulerDomain *result = 0 ;
77570
77571   arg1 = (float)jarg1;
77572   arg2 = (float)jarg2;
77573   arg3 = jarg3 ? true : false;
77574   {
77575     try {
77576       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77577     } catch (std::out_of_range& e) {
77578       {
77579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77580       };
77581     } catch (std::exception& e) {
77582       {
77583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77584       };
77585     } catch (Dali::DaliException e) {
77586       {
77587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77588       };
77589     } catch (...) {
77590       {
77591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77592       };
77593     }
77594   }
77595
77596   jresult = (void *)result;
77597   return jresult;
77598 }
77599
77600
77601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77602   void * jresult ;
77603   float arg1 ;
77604   float arg2 ;
77605   Dali::Toolkit::RulerDomain *result = 0 ;
77606
77607   arg1 = (float)jarg1;
77608   arg2 = (float)jarg2;
77609   {
77610     try {
77611       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77612     } catch (std::out_of_range& e) {
77613       {
77614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77615       };
77616     } catch (std::exception& e) {
77617       {
77618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77619       };
77620     } catch (Dali::DaliException e) {
77621       {
77622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77623       };
77624     } catch (...) {
77625       {
77626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77627       };
77628     }
77629   }
77630
77631   jresult = (void *)result;
77632   return jresult;
77633 }
77634
77635
77636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77637   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77638   float arg2 ;
77639
77640   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77641   arg2 = (float)jarg2;
77642   if (arg1) (arg1)->min = arg2;
77643 }
77644
77645
77646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77647   float jresult ;
77648   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77649   float result;
77650
77651   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77652   result = (float) ((arg1)->min);
77653   jresult = result;
77654   return jresult;
77655 }
77656
77657
77658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77659   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77660   float arg2 ;
77661
77662   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77663   arg2 = (float)jarg2;
77664   if (arg1) (arg1)->max = arg2;
77665 }
77666
77667
77668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77669   float jresult ;
77670   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77671   float result;
77672
77673   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77674   result = (float) ((arg1)->max);
77675   jresult = result;
77676   return jresult;
77677 }
77678
77679
77680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77681   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77682   bool arg2 ;
77683
77684   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77685   arg2 = jarg2 ? true : false;
77686   if (arg1) (arg1)->enabled = arg2;
77687 }
77688
77689
77690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77691   unsigned int jresult ;
77692   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77693   bool result;
77694
77695   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77696   result = (bool) ((arg1)->enabled);
77697   jresult = result;
77698   return jresult;
77699 }
77700
77701
77702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77703   float jresult ;
77704   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77705   float arg2 ;
77706   float arg3 ;
77707   float arg4 ;
77708   float result;
77709
77710   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77711   arg2 = (float)jarg2;
77712   arg3 = (float)jarg3;
77713   arg4 = (float)jarg4;
77714   {
77715     try {
77716       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77717     } catch (std::out_of_range& e) {
77718       {
77719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77720       };
77721     } catch (std::exception& e) {
77722       {
77723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77724       };
77725     } catch (Dali::DaliException e) {
77726       {
77727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77728       };
77729     } catch (...) {
77730       {
77731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77732       };
77733     }
77734   }
77735
77736   jresult = result;
77737   return jresult;
77738 }
77739
77740
77741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77742   float jresult ;
77743   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77744   float arg2 ;
77745   float arg3 ;
77746   float result;
77747
77748   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77749   arg2 = (float)jarg2;
77750   arg3 = (float)jarg3;
77751   {
77752     try {
77753       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77754     } catch (std::out_of_range& e) {
77755       {
77756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77757       };
77758     } catch (std::exception& e) {
77759       {
77760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77761       };
77762     } catch (Dali::DaliException e) {
77763       {
77764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77765       };
77766     } catch (...) {
77767       {
77768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77769       };
77770     }
77771   }
77772
77773   jresult = result;
77774   return jresult;
77775 }
77776
77777
77778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77779   float jresult ;
77780   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77781   float arg2 ;
77782   float result;
77783
77784   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77785   arg2 = (float)jarg2;
77786   {
77787     try {
77788       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77789     } catch (std::out_of_range& e) {
77790       {
77791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77792       };
77793     } catch (std::exception& e) {
77794       {
77795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77796       };
77797     } catch (Dali::DaliException e) {
77798       {
77799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77800       };
77801     } catch (...) {
77802       {
77803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77804       };
77805     }
77806   }
77807
77808   jresult = result;
77809   return jresult;
77810 }
77811
77812
77813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77814   float jresult ;
77815   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77816   float arg2 ;
77817   float arg3 ;
77818   float arg4 ;
77819   Dali::Toolkit::ClampState *arg5 = 0 ;
77820   float result;
77821
77822   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77823   arg2 = (float)jarg2;
77824   arg3 = (float)jarg3;
77825   arg4 = (float)jarg4;
77826   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77827   if (!arg5) {
77828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77829     return 0;
77830   }
77831   {
77832     try {
77833       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77834     } catch (std::out_of_range& e) {
77835       {
77836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77837       };
77838     } catch (std::exception& e) {
77839       {
77840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77841       };
77842     } catch (Dali::DaliException e) {
77843       {
77844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77845       };
77846     } catch (...) {
77847       {
77848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77849       };
77850     }
77851   }
77852
77853   jresult = result;
77854   return jresult;
77855 }
77856
77857
77858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
77859   float jresult ;
77860   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77861   float result;
77862
77863   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77864   {
77865     try {
77866       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
77867     } catch (std::out_of_range& e) {
77868       {
77869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77870       };
77871     } catch (std::exception& e) {
77872       {
77873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77874       };
77875     } catch (Dali::DaliException e) {
77876       {
77877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77878       };
77879     } catch (...) {
77880       {
77881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77882       };
77883     }
77884   }
77885
77886   jresult = result;
77887   return jresult;
77888 }
77889
77890
77891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77892   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77893
77894   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77895   {
77896     try {
77897       delete arg1;
77898     } catch (std::out_of_range& e) {
77899       {
77900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77901       };
77902     } catch (std::exception& e) {
77903       {
77904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77905       };
77906     } catch (Dali::DaliException e) {
77907       {
77908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77909       };
77910     } catch (...) {
77911       {
77912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77913       };
77914     }
77915   }
77916
77917 }
77918
77919
77920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77921   float jresult ;
77922   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77923   float arg2 ;
77924   float arg3 ;
77925   float result;
77926
77927   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77928   arg2 = (float)jarg2;
77929   arg3 = (float)jarg3;
77930   {
77931     try {
77932       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77933     } catch (std::out_of_range& e) {
77934       {
77935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77936       };
77937     } catch (std::exception& e) {
77938       {
77939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77940       };
77941     } catch (Dali::DaliException e) {
77942       {
77943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77944       };
77945     } catch (...) {
77946       {
77947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77948       };
77949     }
77950   }
77951
77952   jresult = result;
77953   return jresult;
77954 }
77955
77956
77957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77958   float jresult ;
77959   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77960   float arg2 ;
77961   float result;
77962
77963   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77964   arg2 = (float)jarg2;
77965   {
77966     try {
77967       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77968     } catch (std::out_of_range& e) {
77969       {
77970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77971       };
77972     } catch (std::exception& e) {
77973       {
77974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77975       };
77976     } catch (Dali::DaliException e) {
77977       {
77978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77979       };
77980     } catch (...) {
77981       {
77982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77983       };
77984     }
77985   }
77986
77987   jresult = result;
77988   return jresult;
77989 }
77990
77991
77992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77993   float jresult ;
77994   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77995   unsigned int arg2 ;
77996   unsigned int *arg3 = 0 ;
77997   bool arg4 ;
77998   float result;
77999
78000   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78001   arg2 = (unsigned int)jarg2;
78002   arg3 = (unsigned int *)jarg3;
78003   arg4 = jarg4 ? true : false;
78004   {
78005     try {
78006       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78007     } catch (std::out_of_range& e) {
78008       {
78009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78010       };
78011     } catch (std::exception& e) {
78012       {
78013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78014       };
78015     } catch (Dali::DaliException e) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78018       };
78019     } catch (...) {
78020       {
78021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78022       };
78023     }
78024   }
78025
78026   jresult = result;
78027   return jresult;
78028 }
78029
78030
78031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78032   unsigned int jresult ;
78033   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78034   float arg2 ;
78035   bool arg3 ;
78036   unsigned int result;
78037
78038   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78039   arg2 = (float)jarg2;
78040   arg3 = jarg3 ? true : false;
78041   {
78042     try {
78043       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78044     } catch (std::out_of_range& e) {
78045       {
78046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78047       };
78048     } catch (std::exception& e) {
78049       {
78050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78051       };
78052     } catch (Dali::DaliException e) {
78053       {
78054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78055       };
78056     } catch (...) {
78057       {
78058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78059       };
78060     }
78061   }
78062
78063   jresult = result;
78064   return jresult;
78065 }
78066
78067
78068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78069   unsigned int jresult ;
78070   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78071   unsigned int result;
78072
78073   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78074   {
78075     try {
78076       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78077     } catch (std::out_of_range& e) {
78078       {
78079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78080       };
78081     } catch (std::exception& e) {
78082       {
78083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78084       };
78085     } catch (Dali::DaliException e) {
78086       {
78087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78088       };
78089     } catch (...) {
78090       {
78091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78092       };
78093     }
78094   }
78095
78096   jresult = result;
78097   return jresult;
78098 }
78099
78100
78101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78102   int jresult ;
78103   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78104   Dali::Toolkit::Ruler::RulerType result;
78105
78106   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78107   {
78108     try {
78109       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78110     } catch (std::out_of_range& e) {
78111       {
78112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78113       };
78114     } catch (std::exception& e) {
78115       {
78116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78117       };
78118     } catch (Dali::DaliException e) {
78119       {
78120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78121       };
78122     } catch (...) {
78123       {
78124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78125       };
78126     }
78127   }
78128
78129   jresult = (int)result;
78130   return jresult;
78131 }
78132
78133
78134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78135   unsigned int jresult ;
78136   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78137   bool result;
78138
78139   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78140   {
78141     try {
78142       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78143     } catch (std::out_of_range& e) {
78144       {
78145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78146       };
78147     } catch (std::exception& e) {
78148       {
78149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78150       };
78151     } catch (Dali::DaliException e) {
78152       {
78153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78154       };
78155     } catch (...) {
78156       {
78157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78158       };
78159     }
78160   }
78161
78162   jresult = result;
78163   return jresult;
78164 }
78165
78166
78167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78168   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78169
78170   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78171   {
78172     try {
78173       (arg1)->Enable();
78174     } catch (std::out_of_range& e) {
78175       {
78176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78177       };
78178     } catch (std::exception& e) {
78179       {
78180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78181       };
78182     } catch (Dali::DaliException e) {
78183       {
78184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78185       };
78186     } catch (...) {
78187       {
78188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78189       };
78190     }
78191   }
78192
78193 }
78194
78195
78196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78197   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78198
78199   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78200   {
78201     try {
78202       (arg1)->Disable();
78203     } catch (std::out_of_range& e) {
78204       {
78205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78206       };
78207     } catch (std::exception& e) {
78208       {
78209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78210       };
78211     } catch (Dali::DaliException e) {
78212       {
78213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78214       };
78215     } catch (...) {
78216       {
78217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78218       };
78219     }
78220   }
78221
78222 }
78223
78224
78225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78226   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78227   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78228   Dali::Toolkit::RulerDomain *argp2 ;
78229
78230   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78231   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78232   if (!argp2) {
78233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78234     return ;
78235   }
78236   arg2 = *argp2;
78237   {
78238     try {
78239       (arg1)->SetDomain(arg2);
78240     } catch (std::out_of_range& e) {
78241       {
78242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78243       };
78244     } catch (std::exception& e) {
78245       {
78246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78247       };
78248     } catch (Dali::DaliException e) {
78249       {
78250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78251       };
78252     } catch (...) {
78253       {
78254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78255       };
78256     }
78257   }
78258
78259 }
78260
78261
78262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78263   void * jresult ;
78264   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78265   Dali::Toolkit::RulerDomain *result = 0 ;
78266
78267   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78268   {
78269     try {
78270       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78271     } catch (std::out_of_range& e) {
78272       {
78273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78274       };
78275     } catch (std::exception& e) {
78276       {
78277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78278       };
78279     } catch (Dali::DaliException e) {
78280       {
78281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78282       };
78283     } catch (...) {
78284       {
78285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78286       };
78287     }
78288   }
78289
78290   jresult = (void *)result;
78291   return jresult;
78292 }
78293
78294
78295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78296   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78297
78298   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78299   {
78300     try {
78301       (arg1)->DisableDomain();
78302     } catch (std::out_of_range& e) {
78303       {
78304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78305       };
78306     } catch (std::exception& e) {
78307       {
78308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78309       };
78310     } catch (Dali::DaliException e) {
78311       {
78312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78313       };
78314     } catch (...) {
78315       {
78316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78317       };
78318     }
78319   }
78320
78321 }
78322
78323
78324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78325   float jresult ;
78326   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78327   float arg2 ;
78328   float arg3 ;
78329   float arg4 ;
78330   float result;
78331
78332   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78333   arg2 = (float)jarg2;
78334   arg3 = (float)jarg3;
78335   arg4 = (float)jarg4;
78336   {
78337     try {
78338       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78339     } catch (std::out_of_range& e) {
78340       {
78341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78342       };
78343     } catch (std::exception& e) {
78344       {
78345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78346       };
78347     } catch (Dali::DaliException e) {
78348       {
78349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78350       };
78351     } catch (...) {
78352       {
78353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78354       };
78355     }
78356   }
78357
78358   jresult = result;
78359   return jresult;
78360 }
78361
78362
78363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78364   float jresult ;
78365   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78366   float arg2 ;
78367   float arg3 ;
78368   float result;
78369
78370   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78371   arg2 = (float)jarg2;
78372   arg3 = (float)jarg3;
78373   {
78374     try {
78375       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78376     } catch (std::out_of_range& e) {
78377       {
78378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78379       };
78380     } catch (std::exception& e) {
78381       {
78382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78383       };
78384     } catch (Dali::DaliException e) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78387       };
78388     } catch (...) {
78389       {
78390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78391       };
78392     }
78393   }
78394
78395   jresult = result;
78396   return jresult;
78397 }
78398
78399
78400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78401   float jresult ;
78402   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78403   float arg2 ;
78404   float result;
78405
78406   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78407   arg2 = (float)jarg2;
78408   {
78409     try {
78410       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78411     } catch (std::out_of_range& e) {
78412       {
78413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78414       };
78415     } catch (std::exception& e) {
78416       {
78417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78418       };
78419     } catch (Dali::DaliException e) {
78420       {
78421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78422       };
78423     } catch (...) {
78424       {
78425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78426       };
78427     }
78428   }
78429
78430   jresult = result;
78431   return jresult;
78432 }
78433
78434
78435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78436   float jresult ;
78437   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78438   float arg2 ;
78439   float arg3 ;
78440   float arg4 ;
78441   Dali::Toolkit::ClampState *arg5 = 0 ;
78442   float result;
78443
78444   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78445   arg2 = (float)jarg2;
78446   arg3 = (float)jarg3;
78447   arg4 = (float)jarg4;
78448   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78449   if (!arg5) {
78450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78451     return 0;
78452   }
78453   {
78454     try {
78455       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78456     } catch (std::out_of_range& e) {
78457       {
78458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78459       };
78460     } catch (std::exception& e) {
78461       {
78462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78463       };
78464     } catch (Dali::DaliException e) {
78465       {
78466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78467       };
78468     } catch (...) {
78469       {
78470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78471       };
78472     }
78473   }
78474
78475   jresult = result;
78476   return jresult;
78477 }
78478
78479
78480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78481   float jresult ;
78482   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78483   float arg2 ;
78484   float arg3 ;
78485   float arg4 ;
78486   float arg5 ;
78487   float result;
78488
78489   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78490   arg2 = (float)jarg2;
78491   arg3 = (float)jarg3;
78492   arg4 = (float)jarg4;
78493   arg5 = (float)jarg5;
78494   {
78495     try {
78496       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78497     } catch (std::out_of_range& e) {
78498       {
78499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78500       };
78501     } catch (std::exception& e) {
78502       {
78503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78504       };
78505     } catch (Dali::DaliException e) {
78506       {
78507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78508       };
78509     } catch (...) {
78510       {
78511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78512       };
78513     }
78514   }
78515
78516   jresult = result;
78517   return jresult;
78518 }
78519
78520
78521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78522   float jresult ;
78523   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78524   float arg2 ;
78525   float arg3 ;
78526   float arg4 ;
78527   float result;
78528
78529   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78530   arg2 = (float)jarg2;
78531   arg3 = (float)jarg3;
78532   arg4 = (float)jarg4;
78533   {
78534     try {
78535       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78536     } catch (std::out_of_range& e) {
78537       {
78538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78539       };
78540     } catch (std::exception& e) {
78541       {
78542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78543       };
78544     } catch (Dali::DaliException e) {
78545       {
78546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78547       };
78548     } catch (...) {
78549       {
78550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78551       };
78552     }
78553   }
78554
78555   jresult = result;
78556   return jresult;
78557 }
78558
78559
78560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78561   float jresult ;
78562   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78563   float arg2 ;
78564   float arg3 ;
78565   float result;
78566
78567   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78568   arg2 = (float)jarg2;
78569   arg3 = (float)jarg3;
78570   {
78571     try {
78572       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78573     } catch (std::out_of_range& e) {
78574       {
78575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78576       };
78577     } catch (std::exception& e) {
78578       {
78579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78580       };
78581     } catch (Dali::DaliException e) {
78582       {
78583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78584       };
78585     } catch (...) {
78586       {
78587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78588       };
78589     }
78590   }
78591
78592   jresult = result;
78593   return jresult;
78594 }
78595
78596
78597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78598   float jresult ;
78599   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78600   float arg2 ;
78601   float result;
78602
78603   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78604   arg2 = (float)jarg2;
78605   {
78606     try {
78607       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78608     } catch (std::out_of_range& e) {
78609       {
78610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78611       };
78612     } catch (std::exception& e) {
78613       {
78614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78615       };
78616     } catch (Dali::DaliException e) {
78617       {
78618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78619       };
78620     } catch (...) {
78621       {
78622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78623       };
78624     }
78625   }
78626
78627   jresult = result;
78628   return jresult;
78629 }
78630
78631
78632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78633   float jresult ;
78634   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78635   float arg2 ;
78636   float arg3 ;
78637   float arg4 ;
78638   float arg5 ;
78639   Dali::Toolkit::ClampState *arg6 = 0 ;
78640   float result;
78641
78642   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78643   arg2 = (float)jarg2;
78644   arg3 = (float)jarg3;
78645   arg4 = (float)jarg4;
78646   arg5 = (float)jarg5;
78647   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78648   if (!arg6) {
78649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78650     return 0;
78651   }
78652   {
78653     try {
78654       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78655     } catch (std::out_of_range& e) {
78656       {
78657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78658       };
78659     } catch (std::exception& e) {
78660       {
78661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78662       };
78663     } catch (Dali::DaliException e) {
78664       {
78665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78666       };
78667     } catch (...) {
78668       {
78669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78670       };
78671     }
78672   }
78673
78674   jresult = result;
78675   return jresult;
78676 }
78677
78678
78679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78680   void * jresult ;
78681   Dali::Toolkit::DefaultRuler *result = 0 ;
78682
78683   {
78684     try {
78685       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78686     } catch (std::out_of_range& e) {
78687       {
78688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78689       };
78690     } catch (std::exception& e) {
78691       {
78692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78693       };
78694     } catch (Dali::DaliException e) {
78695       {
78696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78697       };
78698     } catch (...) {
78699       {
78700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78701       };
78702     }
78703   }
78704
78705   jresult = (void *)result;
78706   return jresult;
78707 }
78708
78709
78710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78711   float jresult ;
78712   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78713   float arg2 ;
78714   float arg3 ;
78715   float result;
78716
78717   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78718   arg2 = (float)jarg2;
78719   arg3 = (float)jarg3;
78720   {
78721     try {
78722       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78723     } catch (std::out_of_range& e) {
78724       {
78725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78726       };
78727     } catch (std::exception& e) {
78728       {
78729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78730       };
78731     } catch (Dali::DaliException e) {
78732       {
78733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78734       };
78735     } catch (...) {
78736       {
78737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78738       };
78739     }
78740   }
78741
78742   jresult = result;
78743   return jresult;
78744 }
78745
78746
78747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78748   float jresult ;
78749   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78750   unsigned int arg2 ;
78751   unsigned int *arg3 = 0 ;
78752   bool arg4 ;
78753   float result;
78754
78755   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78756   arg2 = (unsigned int)jarg2;
78757   arg3 = (unsigned int *)jarg3;
78758   arg4 = jarg4 ? true : false;
78759   {
78760     try {
78761       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78762     } catch (std::out_of_range& e) {
78763       {
78764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78765       };
78766     } catch (std::exception& e) {
78767       {
78768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78769       };
78770     } catch (Dali::DaliException e) {
78771       {
78772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78773       };
78774     } catch (...) {
78775       {
78776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78777       };
78778     }
78779   }
78780
78781   jresult = result;
78782   return jresult;
78783 }
78784
78785
78786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78787   unsigned int jresult ;
78788   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78789   float arg2 ;
78790   bool arg3 ;
78791   unsigned int result;
78792
78793   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78794   arg2 = (float)jarg2;
78795   arg3 = jarg3 ? true : false;
78796   {
78797     try {
78798       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78799     } catch (std::out_of_range& e) {
78800       {
78801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78802       };
78803     } catch (std::exception& e) {
78804       {
78805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (Dali::DaliException e) {
78808       {
78809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78810       };
78811     } catch (...) {
78812       {
78813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78814       };
78815     }
78816   }
78817
78818   jresult = result;
78819   return jresult;
78820 }
78821
78822
78823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78824   unsigned int jresult ;
78825   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78826   unsigned int result;
78827
78828   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78829   {
78830     try {
78831       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78832     } catch (std::out_of_range& e) {
78833       {
78834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78835       };
78836     } catch (std::exception& e) {
78837       {
78838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78839       };
78840     } catch (Dali::DaliException e) {
78841       {
78842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78843       };
78844     } catch (...) {
78845       {
78846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78847       };
78848     }
78849   }
78850
78851   jresult = result;
78852   return jresult;
78853 }
78854
78855
78856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
78857   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78858
78859   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78860   {
78861     try {
78862       delete arg1;
78863     } catch (std::out_of_range& e) {
78864       {
78865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78866       };
78867     } catch (std::exception& e) {
78868       {
78869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78870       };
78871     } catch (Dali::DaliException e) {
78872       {
78873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78874       };
78875     } catch (...) {
78876       {
78877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78878       };
78879     }
78880   }
78881
78882 }
78883
78884
78885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
78886   void * jresult ;
78887   float arg1 ;
78888   Dali::Toolkit::FixedRuler *result = 0 ;
78889
78890   arg1 = (float)jarg1;
78891   {
78892     try {
78893       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78894     } catch (std::out_of_range& e) {
78895       {
78896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78897       };
78898     } catch (std::exception& e) {
78899       {
78900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78901       };
78902     } catch (Dali::DaliException e) {
78903       {
78904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78905       };
78906     } catch (...) {
78907       {
78908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78909       };
78910     }
78911   }
78912
78913   jresult = (void *)result;
78914   return jresult;
78915 }
78916
78917
78918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78919   void * jresult ;
78920   Dali::Toolkit::FixedRuler *result = 0 ;
78921
78922   {
78923     try {
78924       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78925     } catch (std::out_of_range& e) {
78926       {
78927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78928       };
78929     } catch (std::exception& e) {
78930       {
78931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78932       };
78933     } catch (Dali::DaliException e) {
78934       {
78935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78936       };
78937     } catch (...) {
78938       {
78939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78940       };
78941     }
78942   }
78943
78944   jresult = (void *)result;
78945   return jresult;
78946 }
78947
78948
78949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78950   float jresult ;
78951   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78952   float arg2 ;
78953   float arg3 ;
78954   float result;
78955
78956   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78957   arg2 = (float)jarg2;
78958   arg3 = (float)jarg3;
78959   {
78960     try {
78961       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78962     } catch (std::out_of_range& e) {
78963       {
78964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78965       };
78966     } catch (std::exception& e) {
78967       {
78968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78969       };
78970     } catch (Dali::DaliException e) {
78971       {
78972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78973       };
78974     } catch (...) {
78975       {
78976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78977       };
78978     }
78979   }
78980
78981   jresult = result;
78982   return jresult;
78983 }
78984
78985
78986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78987   float jresult ;
78988   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78989   unsigned int arg2 ;
78990   unsigned int *arg3 = 0 ;
78991   bool arg4 ;
78992   float result;
78993
78994   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78995   arg2 = (unsigned int)jarg2;
78996   arg3 = (unsigned int *)jarg3;
78997   arg4 = jarg4 ? true : false;
78998   {
78999     try {
79000       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79001     } catch (std::out_of_range& e) {
79002       {
79003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79004       };
79005     } catch (std::exception& e) {
79006       {
79007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79008       };
79009     } catch (Dali::DaliException e) {
79010       {
79011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79012       };
79013     } catch (...) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79016       };
79017     }
79018   }
79019
79020   jresult = result;
79021   return jresult;
79022 }
79023
79024
79025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79026   unsigned int jresult ;
79027   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79028   float arg2 ;
79029   bool arg3 ;
79030   unsigned int result;
79031
79032   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79033   arg2 = (float)jarg2;
79034   arg3 = jarg3 ? true : false;
79035   {
79036     try {
79037       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79038     } catch (std::out_of_range& e) {
79039       {
79040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79041       };
79042     } catch (std::exception& e) {
79043       {
79044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79045       };
79046     } catch (Dali::DaliException e) {
79047       {
79048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79049       };
79050     } catch (...) {
79051       {
79052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79053       };
79054     }
79055   }
79056
79057   jresult = result;
79058   return jresult;
79059 }
79060
79061
79062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79063   unsigned int jresult ;
79064   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79065   unsigned int result;
79066
79067   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79068   {
79069     try {
79070       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79071     } catch (std::out_of_range& e) {
79072       {
79073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79074       };
79075     } catch (std::exception& e) {
79076       {
79077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79078       };
79079     } catch (Dali::DaliException e) {
79080       {
79081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79082       };
79083     } catch (...) {
79084       {
79085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79086       };
79087     }
79088   }
79089
79090   jresult = result;
79091   return jresult;
79092 }
79093
79094
79095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79096   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79097
79098   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79099   {
79100     try {
79101       delete arg1;
79102     } catch (std::out_of_range& e) {
79103       {
79104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79105       };
79106     } catch (std::exception& e) {
79107       {
79108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79109       };
79110     } catch (Dali::DaliException e) {
79111       {
79112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79113       };
79114     } catch (...) {
79115       {
79116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79117       };
79118     }
79119   }
79120
79121 }
79122
79123
79124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79125   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79126   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79127
79128   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79129   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79130   if (arg1) (arg1)->scale = *arg2;
79131 }
79132
79133
79134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79135   void * jresult ;
79136   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79137   Dali::Toolkit::ClampState2D *result = 0 ;
79138
79139   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79140   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79141   jresult = (void *)result;
79142   return jresult;
79143 }
79144
79145
79146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79147   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79148   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79149
79150   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79151   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79152   if (arg1) (arg1)->position = *arg2;
79153 }
79154
79155
79156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79157   void * jresult ;
79158   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79159   Dali::Toolkit::ClampState2D *result = 0 ;
79160
79161   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79162   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79163   jresult = (void *)result;
79164   return jresult;
79165 }
79166
79167
79168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79169   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79170   Dali::Toolkit::ClampState arg2 ;
79171
79172   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79173   arg2 = (Dali::Toolkit::ClampState)jarg2;
79174   if (arg1) (arg1)->rotation = arg2;
79175 }
79176
79177
79178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79179   int jresult ;
79180   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79181   Dali::Toolkit::ClampState result;
79182
79183   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79184   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79185   jresult = (int)result;
79186   return jresult;
79187 }
79188
79189
79190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79191   void * jresult ;
79192   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79193
79194   {
79195     try {
79196       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79197     } catch (std::out_of_range& e) {
79198       {
79199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79200       };
79201     } catch (std::exception& e) {
79202       {
79203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79204       };
79205     } catch (Dali::DaliException e) {
79206       {
79207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79208       };
79209     } catch (...) {
79210       {
79211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79212       };
79213     }
79214   }
79215
79216   jresult = (void *)result;
79217   return jresult;
79218 }
79219
79220
79221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79222   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79223
79224   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79225   {
79226     try {
79227       delete arg1;
79228     } catch (std::out_of_range& e) {
79229       {
79230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79231       };
79232     } catch (std::exception& e) {
79233       {
79234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79235       };
79236     } catch (Dali::DaliException e) {
79237       {
79238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79239       };
79240     } catch (...) {
79241       {
79242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79243       };
79244     }
79245   }
79246
79247 }
79248
79249
79250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79251   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79252   Dali::Toolkit::SnapType arg2 ;
79253
79254   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79255   arg2 = (Dali::Toolkit::SnapType)jarg2;
79256   if (arg1) (arg1)->type = arg2;
79257 }
79258
79259
79260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79261   int jresult ;
79262   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79263   Dali::Toolkit::SnapType result;
79264
79265   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79266   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79267   jresult = (int)result;
79268   return jresult;
79269 }
79270
79271
79272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79273   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79274   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79275
79276   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79277   arg2 = (Dali::Vector2 *)jarg2;
79278   if (arg1) (arg1)->position = *arg2;
79279 }
79280
79281
79282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79283   void * jresult ;
79284   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79285   Dali::Vector2 *result = 0 ;
79286
79287   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79288   result = (Dali::Vector2 *)& ((arg1)->position);
79289   jresult = (void *)result;
79290   return jresult;
79291 }
79292
79293
79294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79295   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79296   float arg2 ;
79297
79298   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79299   arg2 = (float)jarg2;
79300   if (arg1) (arg1)->duration = arg2;
79301 }
79302
79303
79304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79305   float jresult ;
79306   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79307   float result;
79308
79309   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79310   result = (float) ((arg1)->duration);
79311   jresult = result;
79312   return jresult;
79313 }
79314
79315
79316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79317   void * jresult ;
79318   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79319
79320   {
79321     try {
79322       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79323     } catch (std::out_of_range& e) {
79324       {
79325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79326       };
79327     } catch (std::exception& e) {
79328       {
79329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79330       };
79331     } catch (Dali::DaliException e) {
79332       {
79333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79334       };
79335     } catch (...) {
79336       {
79337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79338       };
79339     }
79340   }
79341
79342   jresult = (void *)result;
79343   return jresult;
79344 }
79345
79346
79347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79348   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79349
79350   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79351   {
79352     try {
79353       delete arg1;
79354     } catch (std::out_of_range& e) {
79355       {
79356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79357       };
79358     } catch (std::exception& e) {
79359       {
79360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79361       };
79362     } catch (Dali::DaliException e) {
79363       {
79364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79365       };
79366     } catch (...) {
79367       {
79368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79369       };
79370     }
79371   }
79372
79373 }
79374
79375
79376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79377   int jresult ;
79378   int result;
79379
79380   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79381   jresult = (int)result;
79382   return jresult;
79383 }
79384
79385
79386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79387   int jresult ;
79388   int result;
79389
79390   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79391   jresult = (int)result;
79392   return jresult;
79393 }
79394
79395
79396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79397   int jresult ;
79398   int result;
79399
79400   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79401   jresult = (int)result;
79402   return jresult;
79403 }
79404
79405
79406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79407   int jresult ;
79408   int result;
79409
79410   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79411   jresult = (int)result;
79412   return jresult;
79413 }
79414
79415
79416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79417   int jresult ;
79418   int result;
79419
79420   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79421   jresult = (int)result;
79422   return jresult;
79423 }
79424
79425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79426   int jresult ;
79427   int result;
79428
79429   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79430   jresult = (int)result;
79431   return jresult;
79432 }
79433
79434
79435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79436   int jresult ;
79437   int result;
79438
79439   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79440   jresult = (int)result;
79441   return jresult;
79442 }
79443
79444
79445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79446   int jresult ;
79447   int result;
79448
79449   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79450   jresult = (int)result;
79451   return jresult;
79452 }
79453
79454
79455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79456   int jresult ;
79457   int result;
79458
79459   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79460   jresult = (int)result;
79461   return jresult;
79462 }
79463
79464
79465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79466   int jresult ;
79467   int result;
79468
79469   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79470   jresult = (int)result;
79471   return jresult;
79472 }
79473
79474
79475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79476   int jresult ;
79477   int result;
79478
79479   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79480   jresult = (int)result;
79481   return jresult;
79482 }
79483
79484
79485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79486   int jresult ;
79487   int result;
79488
79489   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79490   jresult = (int)result;
79491   return jresult;
79492 }
79493
79494
79495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79496   int jresult ;
79497   int result;
79498
79499   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79500   jresult = (int)result;
79501   return jresult;
79502 }
79503
79504
79505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79506   int jresult ;
79507   int result;
79508
79509   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79510   jresult = (int)result;
79511   return jresult;
79512 }
79513
79514
79515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79516   int jresult ;
79517   int result;
79518
79519   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79520   jresult = (int)result;
79521   return jresult;
79522 }
79523
79524
79525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79526   int jresult ;
79527   int result;
79528
79529   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79530   jresult = (int)result;
79531   return jresult;
79532 }
79533
79534
79535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79536   int jresult ;
79537   int result;
79538
79539   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79540   jresult = (int)result;
79541   return jresult;
79542 }
79543
79544
79545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79546   int jresult ;
79547   int result;
79548
79549   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79550   jresult = (int)result;
79551   return jresult;
79552 }
79553
79554
79555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79556   int jresult ;
79557   int result;
79558
79559   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79560   jresult = (int)result;
79561   return jresult;
79562 }
79563
79564
79565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79566   int jresult ;
79567   int result;
79568
79569   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79570   jresult = (int)result;
79571   return jresult;
79572 }
79573
79574
79575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79576   int jresult ;
79577   int result;
79578
79579   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79580   jresult = (int)result;
79581   return jresult;
79582 }
79583
79584
79585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79586   int jresult ;
79587   int result;
79588
79589   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79590   jresult = (int)result;
79591   return jresult;
79592 }
79593
79594
79595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79596   int jresult ;
79597   int result;
79598
79599   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79600   jresult = (int)result;
79601   return jresult;
79602 }
79603
79604
79605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79606   int jresult ;
79607   int result;
79608
79609   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79610   jresult = (int)result;
79611   return jresult;
79612 }
79613
79614
79615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79616   int jresult ;
79617   int result;
79618
79619   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79620   jresult = (int)result;
79621   return jresult;
79622 }
79623
79624
79625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79626   int jresult ;
79627   int result;
79628
79629   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79630   jresult = (int)result;
79631   return jresult;
79632 }
79633
79634
79635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79636   void * jresult ;
79637   Dali::Toolkit::ScrollView::Property *result = 0 ;
79638
79639   {
79640     try {
79641       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79642     } catch (std::out_of_range& e) {
79643       {
79644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79645       };
79646     } catch (std::exception& e) {
79647       {
79648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79649       };
79650     } catch (Dali::DaliException e) {
79651       {
79652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79653       };
79654     } catch (...) {
79655       {
79656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79657       };
79658     }
79659   }
79660
79661   jresult = (void *)result;
79662   return jresult;
79663 }
79664
79665
79666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79667   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79668
79669   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79670   {
79671     try {
79672       delete arg1;
79673     } catch (std::out_of_range& e) {
79674       {
79675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79676       };
79677     } catch (std::exception& e) {
79678       {
79679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79680       };
79681     } catch (Dali::DaliException e) {
79682       {
79683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79684       };
79685     } catch (...) {
79686       {
79687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79688       };
79689     }
79690   }
79691
79692 }
79693
79694
79695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79696   void * jresult ;
79697   Dali::Toolkit::ScrollView *result = 0 ;
79698
79699   {
79700     try {
79701       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79702     } catch (std::out_of_range& e) {
79703       {
79704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79705       };
79706     } catch (std::exception& e) {
79707       {
79708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79709       };
79710     } catch (Dali::DaliException e) {
79711       {
79712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79713       };
79714     } catch (...) {
79715       {
79716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79717       };
79718     }
79719   }
79720
79721   jresult = (void *)result;
79722   return jresult;
79723 }
79724
79725
79726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79727   void * jresult ;
79728   Dali::Toolkit::ScrollView *arg1 = 0 ;
79729   Dali::Toolkit::ScrollView *result = 0 ;
79730
79731   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79732   if (!arg1) {
79733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79734     return 0;
79735   }
79736   {
79737     try {
79738       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79739     } catch (std::out_of_range& e) {
79740       {
79741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79742       };
79743     } catch (std::exception& e) {
79744       {
79745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79746       };
79747     } catch (Dali::DaliException e) {
79748       {
79749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79750       };
79751     } catch (...) {
79752       {
79753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79754       };
79755     }
79756   }
79757
79758   jresult = (void *)result;
79759   return jresult;
79760 }
79761
79762
79763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79764   void * jresult ;
79765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79766   Dali::Toolkit::ScrollView *arg2 = 0 ;
79767   Dali::Toolkit::ScrollView *result = 0 ;
79768
79769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79770   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79771   if (!arg2) {
79772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79773     return 0;
79774   }
79775   {
79776     try {
79777       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79778     } catch (std::out_of_range& e) {
79779       {
79780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79781       };
79782     } catch (std::exception& e) {
79783       {
79784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79785       };
79786     } catch (Dali::DaliException e) {
79787       {
79788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79789       };
79790     } catch (...) {
79791       {
79792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79793       };
79794     }
79795   }
79796
79797   jresult = (void *)result;
79798   return jresult;
79799 }
79800
79801
79802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79803   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79804
79805   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79806   {
79807     try {
79808       delete arg1;
79809     } catch (std::out_of_range& e) {
79810       {
79811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79812       };
79813     } catch (std::exception& e) {
79814       {
79815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79816       };
79817     } catch (Dali::DaliException e) {
79818       {
79819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79820       };
79821     } catch (...) {
79822       {
79823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79824       };
79825     }
79826   }
79827
79828 }
79829
79830
79831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79832   void * jresult ;
79833   Dali::Toolkit::ScrollView result;
79834
79835   {
79836     try {
79837       result = Dali::Toolkit::ScrollView::New();
79838     } catch (std::out_of_range& e) {
79839       {
79840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79841       };
79842     } catch (std::exception& e) {
79843       {
79844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79845       };
79846     } catch (Dali::DaliException e) {
79847       {
79848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79849       };
79850     } catch (...) {
79851       {
79852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79853       };
79854     }
79855   }
79856
79857   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79858   return jresult;
79859 }
79860
79861
79862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
79863   void * jresult ;
79864   Dali::BaseHandle arg1 ;
79865   Dali::BaseHandle *argp1 ;
79866   Dali::Toolkit::ScrollView result;
79867
79868   argp1 = (Dali::BaseHandle *)jarg1;
79869   if (!argp1) {
79870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79871     return 0;
79872   }
79873   arg1 = *argp1;
79874   {
79875     try {
79876       result = Dali::Toolkit::ScrollView::DownCast(arg1);
79877     } catch (std::out_of_range& e) {
79878       {
79879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79880       };
79881     } catch (std::exception& e) {
79882       {
79883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79884       };
79885     } catch (Dali::DaliException e) {
79886       {
79887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79888       };
79889     } catch (...) {
79890       {
79891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79892       };
79893     }
79894   }
79895
79896   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79897   return jresult;
79898 }
79899
79900
79901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79902   void * jresult ;
79903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79904   Dali::AlphaFunction result;
79905
79906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79907   {
79908     try {
79909       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79910     } catch (std::out_of_range& e) {
79911       {
79912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79913       };
79914     } catch (std::exception& e) {
79915       {
79916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79917       };
79918     } catch (Dali::DaliException e) {
79919       {
79920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79921       };
79922     } catch (...) {
79923       {
79924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79925       };
79926     }
79927   }
79928
79929   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79930   return jresult;
79931 }
79932
79933
79934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79936   Dali::AlphaFunction arg2 ;
79937   Dali::AlphaFunction *argp2 ;
79938
79939   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79940   argp2 = (Dali::AlphaFunction *)jarg2;
79941   if (!argp2) {
79942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79943     return ;
79944   }
79945   arg2 = *argp2;
79946   {
79947     try {
79948       (arg1)->SetScrollSnapAlphaFunction(arg2);
79949     } catch (std::out_of_range& e) {
79950       {
79951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79952       };
79953     } catch (std::exception& e) {
79954       {
79955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79956       };
79957     } catch (Dali::DaliException e) {
79958       {
79959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79960       };
79961     } catch (...) {
79962       {
79963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79964       };
79965     }
79966   }
79967
79968 }
79969
79970
79971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79972   void * jresult ;
79973   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79974   Dali::AlphaFunction result;
79975
79976   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79977   {
79978     try {
79979       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79980     } catch (std::out_of_range& e) {
79981       {
79982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79983       };
79984     } catch (std::exception& e) {
79985       {
79986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79987       };
79988     } catch (Dali::DaliException e) {
79989       {
79990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79991       };
79992     } catch (...) {
79993       {
79994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79995       };
79996     }
79997   }
79998
79999   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80000   return jresult;
80001 }
80002
80003
80004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80005   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80006   Dali::AlphaFunction arg2 ;
80007   Dali::AlphaFunction *argp2 ;
80008
80009   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80010   argp2 = (Dali::AlphaFunction *)jarg2;
80011   if (!argp2) {
80012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80013     return ;
80014   }
80015   arg2 = *argp2;
80016   {
80017     try {
80018       (arg1)->SetScrollFlickAlphaFunction(arg2);
80019     } catch (std::out_of_range& e) {
80020       {
80021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80022       };
80023     } catch (std::exception& e) {
80024       {
80025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80026       };
80027     } catch (Dali::DaliException e) {
80028       {
80029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80030       };
80031     } catch (...) {
80032       {
80033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80034       };
80035     }
80036   }
80037
80038 }
80039
80040
80041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80042   float jresult ;
80043   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80044   float result;
80045
80046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80047   {
80048     try {
80049       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80050     } catch (std::out_of_range& e) {
80051       {
80052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80053       };
80054     } catch (std::exception& e) {
80055       {
80056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80057       };
80058     } catch (Dali::DaliException e) {
80059       {
80060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80061       };
80062     } catch (...) {
80063       {
80064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80065       };
80066     }
80067   }
80068
80069   jresult = result;
80070   return jresult;
80071 }
80072
80073
80074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80075   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80076   float arg2 ;
80077
80078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80079   arg2 = (float)jarg2;
80080   {
80081     try {
80082       (arg1)->SetScrollSnapDuration(arg2);
80083     } catch (std::out_of_range& e) {
80084       {
80085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80086       };
80087     } catch (std::exception& e) {
80088       {
80089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80090       };
80091     } catch (Dali::DaliException e) {
80092       {
80093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80094       };
80095     } catch (...) {
80096       {
80097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80098       };
80099     }
80100   }
80101
80102 }
80103
80104
80105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80106   float jresult ;
80107   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80108   float result;
80109
80110   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80111   {
80112     try {
80113       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80114     } catch (std::out_of_range& e) {
80115       {
80116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80117       };
80118     } catch (std::exception& e) {
80119       {
80120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80121       };
80122     } catch (Dali::DaliException e) {
80123       {
80124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80125       };
80126     } catch (...) {
80127       {
80128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80129       };
80130     }
80131   }
80132
80133   jresult = result;
80134   return jresult;
80135 }
80136
80137
80138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80139   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80140   float arg2 ;
80141
80142   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80143   arg2 = (float)jarg2;
80144   {
80145     try {
80146       (arg1)->SetScrollFlickDuration(arg2);
80147     } catch (std::out_of_range& e) {
80148       {
80149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80150       };
80151     } catch (std::exception& e) {
80152       {
80153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80154       };
80155     } catch (Dali::DaliException e) {
80156       {
80157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80158       };
80159     } catch (...) {
80160       {
80161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80162       };
80163     }
80164   }
80165
80166 }
80167
80168
80169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80170   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80171   Dali::Toolkit::RulerPtr arg2 ;
80172   Dali::Toolkit::RulerPtr *argp2 ;
80173
80174   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80175   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80176   if (!argp2) {
80177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80178     return ;
80179   }
80180   arg2 = *argp2;
80181   {
80182     try {
80183       (arg1)->SetRulerX(arg2);
80184     } catch (std::out_of_range& e) {
80185       {
80186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80187       };
80188     } catch (std::exception& e) {
80189       {
80190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80191       };
80192     } catch (Dali::DaliException e) {
80193       {
80194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80195       };
80196     } catch (...) {
80197       {
80198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80199       };
80200     }
80201   }
80202
80203 }
80204
80205
80206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80208   Dali::Toolkit::RulerPtr arg2 ;
80209   Dali::Toolkit::RulerPtr *argp2 ;
80210
80211   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80212   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80213   if (!argp2) {
80214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80215     return ;
80216   }
80217   arg2 = *argp2;
80218   {
80219     try {
80220       (arg1)->SetRulerY(arg2);
80221     } catch (std::out_of_range& e) {
80222       {
80223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80224       };
80225     } catch (std::exception& e) {
80226       {
80227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80228       };
80229     } catch (Dali::DaliException e) {
80230       {
80231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80232       };
80233     } catch (...) {
80234       {
80235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80236       };
80237     }
80238   }
80239
80240 }
80241
80242
80243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80244   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80245   bool arg2 ;
80246
80247   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80248   arg2 = jarg2 ? true : false;
80249   {
80250     try {
80251       (arg1)->SetScrollSensitive(arg2);
80252     } catch (std::out_of_range& e) {
80253       {
80254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80255       };
80256     } catch (std::exception& e) {
80257       {
80258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80259       };
80260     } catch (Dali::DaliException e) {
80261       {
80262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80263       };
80264     } catch (...) {
80265       {
80266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80267       };
80268     }
80269   }
80270
80271 }
80272
80273
80274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80275   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80276   float arg2 ;
80277   float arg3 ;
80278
80279   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80280   arg2 = (float)jarg2;
80281   arg3 = (float)jarg3;
80282   {
80283     try {
80284       (arg1)->SetMaxOvershoot(arg2,arg3);
80285     } catch (std::out_of_range& e) {
80286       {
80287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80288       };
80289     } catch (std::exception& e) {
80290       {
80291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80292       };
80293     } catch (Dali::DaliException e) {
80294       {
80295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80296       };
80297     } catch (...) {
80298       {
80299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80300       };
80301     }
80302   }
80303
80304 }
80305
80306
80307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80308   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80309   Dali::AlphaFunction arg2 ;
80310   Dali::AlphaFunction *argp2 ;
80311
80312   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80313   argp2 = (Dali::AlphaFunction *)jarg2;
80314   if (!argp2) {
80315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80316     return ;
80317   }
80318   arg2 = *argp2;
80319   {
80320     try {
80321       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80322     } catch (std::out_of_range& e) {
80323       {
80324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80325       };
80326     } catch (std::exception& e) {
80327       {
80328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80329       };
80330     } catch (Dali::DaliException e) {
80331       {
80332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80333       };
80334     } catch (...) {
80335       {
80336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80337       };
80338     }
80339   }
80340
80341 }
80342
80343
80344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80345   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80346   float arg2 ;
80347
80348   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80349   arg2 = (float)jarg2;
80350   {
80351     try {
80352       (arg1)->SetSnapOvershootDuration(arg2);
80353     } catch (std::out_of_range& e) {
80354       {
80355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80356       };
80357     } catch (std::exception& e) {
80358       {
80359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80360       };
80361     } catch (Dali::DaliException e) {
80362       {
80363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80364       };
80365     } catch (...) {
80366       {
80367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80368       };
80369     }
80370   }
80371
80372 }
80373
80374
80375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80376   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80377   bool arg2 ;
80378
80379   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80380   arg2 = jarg2 ? true : false;
80381   {
80382     try {
80383       (arg1)->SetActorAutoSnap(arg2);
80384     } catch (std::out_of_range& e) {
80385       {
80386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80387       };
80388     } catch (std::exception& e) {
80389       {
80390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80391       };
80392     } catch (Dali::DaliException e) {
80393       {
80394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80395       };
80396     } catch (...) {
80397       {
80398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80399       };
80400     }
80401   }
80402
80403 }
80404
80405
80406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80407   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80408   bool arg2 ;
80409
80410   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80411   arg2 = jarg2 ? true : false;
80412   {
80413     try {
80414       (arg1)->SetWrapMode(arg2);
80415     } catch (std::out_of_range& e) {
80416       {
80417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80418       };
80419     } catch (std::exception& e) {
80420       {
80421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80422       };
80423     } catch (Dali::DaliException e) {
80424       {
80425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80426       };
80427     } catch (...) {
80428       {
80429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80430       };
80431     }
80432   }
80433
80434 }
80435
80436
80437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80438   int jresult ;
80439   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80440   int result;
80441
80442   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80443   {
80444     try {
80445       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80446     } catch (std::out_of_range& e) {
80447       {
80448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80449       };
80450     } catch (std::exception& e) {
80451       {
80452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80453       };
80454     } catch (Dali::DaliException e) {
80455       {
80456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80457       };
80458     } catch (...) {
80459       {
80460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80461       };
80462     }
80463   }
80464
80465   jresult = result;
80466   return jresult;
80467 }
80468
80469
80470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80471   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80472   int arg2 ;
80473
80474   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80475   arg2 = (int)jarg2;
80476   {
80477     try {
80478       (arg1)->SetScrollUpdateDistance(arg2);
80479     } catch (std::out_of_range& e) {
80480       {
80481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80482       };
80483     } catch (std::exception& e) {
80484       {
80485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80486       };
80487     } catch (Dali::DaliException e) {
80488       {
80489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80490       };
80491     } catch (...) {
80492       {
80493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80494       };
80495     }
80496   }
80497
80498 }
80499
80500
80501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80502   unsigned int jresult ;
80503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80504   bool result;
80505
80506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80507   {
80508     try {
80509       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80510     } catch (std::out_of_range& e) {
80511       {
80512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80513       };
80514     } catch (std::exception& e) {
80515       {
80516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80517       };
80518     } catch (Dali::DaliException e) {
80519       {
80520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80521       };
80522     } catch (...) {
80523       {
80524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80525       };
80526     }
80527   }
80528
80529   jresult = result;
80530   return jresult;
80531 }
80532
80533
80534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80535   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80536   bool arg2 ;
80537
80538   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80539   arg2 = jarg2 ? true : false;
80540   {
80541     try {
80542       (arg1)->SetAxisAutoLock(arg2);
80543     } catch (std::out_of_range& e) {
80544       {
80545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80546       };
80547     } catch (std::exception& e) {
80548       {
80549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80550       };
80551     } catch (Dali::DaliException e) {
80552       {
80553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80554       };
80555     } catch (...) {
80556       {
80557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80558       };
80559     }
80560   }
80561
80562 }
80563
80564
80565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80566   float jresult ;
80567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80568   float result;
80569
80570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80571   {
80572     try {
80573       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80574     } catch (std::out_of_range& e) {
80575       {
80576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80577       };
80578     } catch (std::exception& e) {
80579       {
80580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80581       };
80582     } catch (Dali::DaliException e) {
80583       {
80584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80585       };
80586     } catch (...) {
80587       {
80588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80589       };
80590     }
80591   }
80592
80593   jresult = result;
80594   return jresult;
80595 }
80596
80597
80598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80599   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80600   float arg2 ;
80601
80602   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80603   arg2 = (float)jarg2;
80604   {
80605     try {
80606       (arg1)->SetAxisAutoLockGradient(arg2);
80607     } catch (std::out_of_range& e) {
80608       {
80609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80610       };
80611     } catch (std::exception& e) {
80612       {
80613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80614       };
80615     } catch (Dali::DaliException e) {
80616       {
80617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80618       };
80619     } catch (...) {
80620       {
80621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80622       };
80623     }
80624   }
80625
80626 }
80627
80628
80629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80630   float jresult ;
80631   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80632   float result;
80633
80634   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80635   {
80636     try {
80637       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80638     } catch (std::out_of_range& e) {
80639       {
80640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80641       };
80642     } catch (std::exception& e) {
80643       {
80644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80645       };
80646     } catch (Dali::DaliException e) {
80647       {
80648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80649       };
80650     } catch (...) {
80651       {
80652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80653       };
80654     }
80655   }
80656
80657   jresult = result;
80658   return jresult;
80659 }
80660
80661
80662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80663   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80664   float arg2 ;
80665
80666   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80667   arg2 = (float)jarg2;
80668   {
80669     try {
80670       (arg1)->SetFrictionCoefficient(arg2);
80671     } catch (std::out_of_range& e) {
80672       {
80673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80674       };
80675     } catch (std::exception& e) {
80676       {
80677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80678       };
80679     } catch (Dali::DaliException e) {
80680       {
80681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80682       };
80683     } catch (...) {
80684       {
80685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80686       };
80687     }
80688   }
80689
80690 }
80691
80692
80693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80694   float jresult ;
80695   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80696   float result;
80697
80698   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80699   {
80700     try {
80701       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80702     } catch (std::out_of_range& e) {
80703       {
80704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80705       };
80706     } catch (std::exception& e) {
80707       {
80708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80709       };
80710     } catch (Dali::DaliException e) {
80711       {
80712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80713       };
80714     } catch (...) {
80715       {
80716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80717       };
80718     }
80719   }
80720
80721   jresult = result;
80722   return jresult;
80723 }
80724
80725
80726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80727   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80728   float arg2 ;
80729
80730   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80731   arg2 = (float)jarg2;
80732   {
80733     try {
80734       (arg1)->SetFlickSpeedCoefficient(arg2);
80735     } catch (std::out_of_range& e) {
80736       {
80737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80738       };
80739     } catch (std::exception& e) {
80740       {
80741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80742       };
80743     } catch (Dali::DaliException e) {
80744       {
80745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80746       };
80747     } catch (...) {
80748       {
80749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80750       };
80751     }
80752   }
80753
80754 }
80755
80756
80757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80758   void * jresult ;
80759   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80760   Dali::Vector2 result;
80761
80762   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80763   {
80764     try {
80765       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80766     } catch (std::out_of_range& e) {
80767       {
80768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80769       };
80770     } catch (std::exception& e) {
80771       {
80772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80773       };
80774     } catch (Dali::DaliException e) {
80775       {
80776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80777       };
80778     } catch (...) {
80779       {
80780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80781       };
80782     }
80783   }
80784
80785   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80786   return jresult;
80787 }
80788
80789
80790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80791   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80792   Dali::Vector2 *arg2 = 0 ;
80793
80794   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80795   arg2 = (Dali::Vector2 *)jarg2;
80796   if (!arg2) {
80797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80798     return ;
80799   }
80800   {
80801     try {
80802       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80803     } catch (std::out_of_range& e) {
80804       {
80805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80806       };
80807     } catch (std::exception& e) {
80808       {
80809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80810       };
80811     } catch (Dali::DaliException e) {
80812       {
80813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80814       };
80815     } catch (...) {
80816       {
80817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80818       };
80819     }
80820   }
80821
80822 }
80823
80824
80825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80826   float jresult ;
80827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80828   float result;
80829
80830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80831   {
80832     try {
80833       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
80834     } catch (std::out_of_range& e) {
80835       {
80836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80837       };
80838     } catch (std::exception& e) {
80839       {
80840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80841       };
80842     } catch (Dali::DaliException e) {
80843       {
80844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80845       };
80846     } catch (...) {
80847       {
80848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80849       };
80850     }
80851   }
80852
80853   jresult = result;
80854   return jresult;
80855 }
80856
80857
80858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
80859   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80860   float arg2 ;
80861
80862   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80863   arg2 = (float)jarg2;
80864   {
80865     try {
80866       (arg1)->SetMinimumSpeedForFlick(arg2);
80867     } catch (std::out_of_range& e) {
80868       {
80869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80870       };
80871     } catch (std::exception& e) {
80872       {
80873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80874       };
80875     } catch (Dali::DaliException e) {
80876       {
80877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80878       };
80879     } catch (...) {
80880       {
80881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80882       };
80883     }
80884   }
80885
80886 }
80887
80888
80889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
80890   float jresult ;
80891   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80892   float result;
80893
80894   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80895   {
80896     try {
80897       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80898     } catch (std::out_of_range& e) {
80899       {
80900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80901       };
80902     } catch (std::exception& e) {
80903       {
80904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80905       };
80906     } catch (Dali::DaliException e) {
80907       {
80908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80909       };
80910     } catch (...) {
80911       {
80912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80913       };
80914     }
80915   }
80916
80917   jresult = result;
80918   return jresult;
80919 }
80920
80921
80922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80923   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80924   float arg2 ;
80925
80926   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80927   arg2 = (float)jarg2;
80928   {
80929     try {
80930       (arg1)->SetMaxFlickSpeed(arg2);
80931     } catch (std::out_of_range& e) {
80932       {
80933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80934       };
80935     } catch (std::exception& e) {
80936       {
80937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80938       };
80939     } catch (Dali::DaliException e) {
80940       {
80941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80942       };
80943     } catch (...) {
80944       {
80945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80946       };
80947     }
80948   }
80949
80950 }
80951
80952
80953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80954   void * jresult ;
80955   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80956   Dali::Vector2 result;
80957
80958   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80959   {
80960     try {
80961       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80962     } catch (std::out_of_range& e) {
80963       {
80964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80965       };
80966     } catch (std::exception& e) {
80967       {
80968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80969       };
80970     } catch (Dali::DaliException e) {
80971       {
80972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80973       };
80974     } catch (...) {
80975       {
80976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80977       };
80978     }
80979   }
80980
80981   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80982   return jresult;
80983 }
80984
80985
80986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80988   Dali::Vector2 arg2 ;
80989   Dali::Vector2 *argp2 ;
80990
80991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80992   argp2 = (Dali::Vector2 *)jarg2;
80993   if (!argp2) {
80994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80995     return ;
80996   }
80997   arg2 = *argp2;
80998   {
80999     try {
81000       (arg1)->SetWheelScrollDistanceStep(arg2);
81001     } catch (std::out_of_range& e) {
81002       {
81003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81004       };
81005     } catch (std::exception& e) {
81006       {
81007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81008       };
81009     } catch (Dali::DaliException e) {
81010       {
81011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81012       };
81013     } catch (...) {
81014       {
81015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81016       };
81017     }
81018   }
81019
81020 }
81021
81022
81023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81024   void * jresult ;
81025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81026   Dali::Vector2 result;
81027
81028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81029   {
81030     try {
81031       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81032     } catch (std::out_of_range& e) {
81033       {
81034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81035       };
81036     } catch (std::exception& e) {
81037       {
81038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81039       };
81040     } catch (Dali::DaliException e) {
81041       {
81042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81043       };
81044     } catch (...) {
81045       {
81046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81047       };
81048     }
81049   }
81050
81051   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81052   return jresult;
81053 }
81054
81055
81056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81057   unsigned int jresult ;
81058   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81059   unsigned int result;
81060
81061   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81062   {
81063     try {
81064       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81065     } catch (std::out_of_range& e) {
81066       {
81067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81068       };
81069     } catch (std::exception& e) {
81070       {
81071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81072       };
81073     } catch (Dali::DaliException e) {
81074       {
81075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81076       };
81077     } catch (...) {
81078       {
81079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81080       };
81081     }
81082   }
81083
81084   jresult = result;
81085   return jresult;
81086 }
81087
81088
81089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81090   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81091   Dali::Vector2 *arg2 = 0 ;
81092
81093   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81094   arg2 = (Dali::Vector2 *)jarg2;
81095   if (!arg2) {
81096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81097     return ;
81098   }
81099   {
81100     try {
81101       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81102     } catch (std::out_of_range& e) {
81103       {
81104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81105       };
81106     } catch (std::exception& e) {
81107       {
81108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81109       };
81110     } catch (Dali::DaliException e) {
81111       {
81112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81113       };
81114     } catch (...) {
81115       {
81116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81117       };
81118     }
81119   }
81120
81121 }
81122
81123
81124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81125   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81126   Dali::Vector2 *arg2 = 0 ;
81127   float arg3 ;
81128
81129   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81130   arg2 = (Dali::Vector2 *)jarg2;
81131   if (!arg2) {
81132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81133     return ;
81134   }
81135   arg3 = (float)jarg3;
81136   {
81137     try {
81138       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81139     } catch (std::out_of_range& e) {
81140       {
81141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81142       };
81143     } catch (std::exception& e) {
81144       {
81145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81146       };
81147     } catch (Dali::DaliException e) {
81148       {
81149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81150       };
81151     } catch (...) {
81152       {
81153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81154       };
81155     }
81156   }
81157
81158 }
81159
81160
81161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81162   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81163   Dali::Vector2 *arg2 = 0 ;
81164   float arg3 ;
81165   Dali::AlphaFunction arg4 ;
81166   Dali::AlphaFunction *argp4 ;
81167
81168   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81169   arg2 = (Dali::Vector2 *)jarg2;
81170   if (!arg2) {
81171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81172     return ;
81173   }
81174   arg3 = (float)jarg3;
81175   argp4 = (Dali::AlphaFunction *)jarg4;
81176   if (!argp4) {
81177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81178     return ;
81179   }
81180   arg4 = *argp4;
81181   {
81182     try {
81183       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81184     } catch (std::out_of_range& e) {
81185       {
81186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81187       };
81188     } catch (std::exception& e) {
81189       {
81190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81191       };
81192     } catch (Dali::DaliException e) {
81193       {
81194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81195       };
81196     } catch (...) {
81197       {
81198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81199       };
81200     }
81201   }
81202
81203 }
81204
81205
81206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81208   Dali::Vector2 *arg2 = 0 ;
81209   float arg3 ;
81210   Dali::Toolkit::DirectionBias arg4 ;
81211   Dali::Toolkit::DirectionBias arg5 ;
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   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81221   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81222   {
81223     try {
81224       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81225     } catch (std::out_of_range& e) {
81226       {
81227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81228       };
81229     } catch (std::exception& e) {
81230       {
81231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81232       };
81233     } catch (Dali::DaliException e) {
81234       {
81235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81236       };
81237     } catch (...) {
81238       {
81239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81240       };
81241     }
81242   }
81243
81244 }
81245
81246
81247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81248   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81249   Dali::Vector2 *arg2 = 0 ;
81250   float arg3 ;
81251   Dali::AlphaFunction arg4 ;
81252   Dali::Toolkit::DirectionBias arg5 ;
81253   Dali::Toolkit::DirectionBias arg6 ;
81254   Dali::AlphaFunction *argp4 ;
81255
81256   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81257   arg2 = (Dali::Vector2 *)jarg2;
81258   if (!arg2) {
81259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81260     return ;
81261   }
81262   arg3 = (float)jarg3;
81263   argp4 = (Dali::AlphaFunction *)jarg4;
81264   if (!argp4) {
81265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81266     return ;
81267   }
81268   arg4 = *argp4;
81269   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81270   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81271   {
81272     try {
81273       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81274     } catch (std::out_of_range& e) {
81275       {
81276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81277       };
81278     } catch (std::exception& e) {
81279       {
81280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81281       };
81282     } catch (Dali::DaliException e) {
81283       {
81284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81285       };
81286     } catch (...) {
81287       {
81288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81289       };
81290     }
81291   }
81292
81293 }
81294
81295
81296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81297   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81298   unsigned int arg2 ;
81299
81300   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81301   arg2 = (unsigned int)jarg2;
81302   {
81303     try {
81304       (arg1)->ScrollTo(arg2);
81305     } catch (std::out_of_range& e) {
81306       {
81307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81308       };
81309     } catch (std::exception& e) {
81310       {
81311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81312       };
81313     } catch (Dali::DaliException e) {
81314       {
81315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81316       };
81317     } catch (...) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81320       };
81321     }
81322   }
81323
81324 }
81325
81326
81327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81329   unsigned int arg2 ;
81330   float arg3 ;
81331
81332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81333   arg2 = (unsigned int)jarg2;
81334   arg3 = (float)jarg3;
81335   {
81336     try {
81337       (arg1)->ScrollTo(arg2,arg3);
81338     } catch (std::out_of_range& e) {
81339       {
81340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81341       };
81342     } catch (std::exception& e) {
81343       {
81344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81345       };
81346     } catch (Dali::DaliException e) {
81347       {
81348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81349       };
81350     } catch (...) {
81351       {
81352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81353       };
81354     }
81355   }
81356
81357 }
81358
81359
81360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81361   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81362   unsigned int arg2 ;
81363   float arg3 ;
81364   Dali::Toolkit::DirectionBias arg4 ;
81365
81366   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81367   arg2 = (unsigned int)jarg2;
81368   arg3 = (float)jarg3;
81369   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81370   {
81371     try {
81372       (arg1)->ScrollTo(arg2,arg3,arg4);
81373     } catch (std::out_of_range& e) {
81374       {
81375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81376       };
81377     } catch (std::exception& e) {
81378       {
81379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81380       };
81381     } catch (Dali::DaliException e) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81388       };
81389     }
81390   }
81391
81392 }
81393
81394
81395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81396   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81397   Dali::Actor *arg2 = 0 ;
81398
81399   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81400   arg2 = (Dali::Actor *)jarg2;
81401   if (!arg2) {
81402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81403     return ;
81404   }
81405   {
81406     try {
81407       (arg1)->ScrollTo(*arg2);
81408     } catch (std::out_of_range& e) {
81409       {
81410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81411       };
81412     } catch (std::exception& e) {
81413       {
81414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81415       };
81416     } catch (Dali::DaliException e) {
81417       {
81418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81419       };
81420     } catch (...) {
81421       {
81422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81423       };
81424     }
81425   }
81426
81427 }
81428
81429
81430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81431   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81432   Dali::Actor *arg2 = 0 ;
81433   float arg3 ;
81434
81435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81436   arg2 = (Dali::Actor *)jarg2;
81437   if (!arg2) {
81438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81439     return ;
81440   }
81441   arg3 = (float)jarg3;
81442   {
81443     try {
81444       (arg1)->ScrollTo(*arg2,arg3);
81445     } catch (std::out_of_range& e) {
81446       {
81447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81448       };
81449     } catch (std::exception& e) {
81450       {
81451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81452       };
81453     } catch (Dali::DaliException e) {
81454       {
81455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81456       };
81457     } catch (...) {
81458       {
81459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81460       };
81461     }
81462   }
81463
81464 }
81465
81466
81467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81468   unsigned int jresult ;
81469   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81470   bool result;
81471
81472   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81473   {
81474     try {
81475       result = (bool)(arg1)->ScrollToSnapPoint();
81476     } catch (std::out_of_range& e) {
81477       {
81478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81479       };
81480     } catch (std::exception& e) {
81481       {
81482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81483       };
81484     } catch (Dali::DaliException e) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81487       };
81488     } catch (...) {
81489       {
81490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81491       };
81492     }
81493   }
81494
81495   jresult = result;
81496   return jresult;
81497 }
81498
81499
81500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81501   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81502   Dali::Constraint arg2 ;
81503   Dali::Constraint *argp2 ;
81504
81505   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81506   argp2 = (Dali::Constraint *)jarg2;
81507   if (!argp2) {
81508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81509     return ;
81510   }
81511   arg2 = *argp2;
81512   {
81513     try {
81514       (arg1)->ApplyConstraintToChildren(arg2);
81515     } catch (std::out_of_range& e) {
81516       {
81517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81518       };
81519     } catch (std::exception& e) {
81520       {
81521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81522       };
81523     } catch (Dali::DaliException e) {
81524       {
81525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81526       };
81527     } catch (...) {
81528       {
81529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81530       };
81531     }
81532   }
81533
81534 }
81535
81536
81537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81539
81540   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81541   {
81542     try {
81543       (arg1)->RemoveConstraintsFromChildren();
81544     } catch (std::out_of_range& e) {
81545       {
81546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81547       };
81548     } catch (std::exception& e) {
81549       {
81550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81551       };
81552     } catch (Dali::DaliException e) {
81553       {
81554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81555       };
81556     } catch (...) {
81557       {
81558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81559       };
81560     }
81561   }
81562
81563 }
81564
81565
81566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81568   Dali::Toolkit::ScrollViewEffect arg2 ;
81569   Dali::Toolkit::ScrollViewEffect *argp2 ;
81570
81571   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81572   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81573   if (!argp2) {
81574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81575     return ;
81576   }
81577   arg2 = *argp2;
81578   {
81579     try {
81580       (arg1)->ApplyEffect(arg2);
81581     } catch (std::out_of_range& e) {
81582       {
81583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81584       };
81585     } catch (std::exception& e) {
81586       {
81587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81588       };
81589     } catch (Dali::DaliException e) {
81590       {
81591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81592       };
81593     } catch (...) {
81594       {
81595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81596       };
81597     }
81598   }
81599
81600 }
81601
81602
81603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81604   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81605   Dali::Toolkit::ScrollViewEffect arg2 ;
81606   Dali::Toolkit::ScrollViewEffect *argp2 ;
81607
81608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81609   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81610   if (!argp2) {
81611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81612     return ;
81613   }
81614   arg2 = *argp2;
81615   {
81616     try {
81617       (arg1)->RemoveEffect(arg2);
81618     } catch (std::out_of_range& e) {
81619       {
81620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81621       };
81622     } catch (std::exception& e) {
81623       {
81624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81625       };
81626     } catch (Dali::DaliException e) {
81627       {
81628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81629       };
81630     } catch (...) {
81631       {
81632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81633       };
81634     }
81635   }
81636
81637 }
81638
81639
81640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81641   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81642
81643   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81644   {
81645     try {
81646       (arg1)->RemoveAllEffects();
81647     } catch (std::out_of_range& e) {
81648       {
81649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81650       };
81651     } catch (std::exception& e) {
81652       {
81653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81654       };
81655     } catch (Dali::DaliException e) {
81656       {
81657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81658       };
81659     } catch (...) {
81660       {
81661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81662       };
81663     }
81664   }
81665
81666 }
81667
81668
81669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81670   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81671   Dali::Actor arg2 ;
81672   Dali::Actor *argp2 ;
81673
81674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81675   argp2 = (Dali::Actor *)jarg2;
81676   if (!argp2) {
81677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81678     return ;
81679   }
81680   arg2 = *argp2;
81681   {
81682     try {
81683       (arg1)->BindActor(arg2);
81684     } catch (std::out_of_range& e) {
81685       {
81686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81687       };
81688     } catch (std::exception& e) {
81689       {
81690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81691       };
81692     } catch (Dali::DaliException e) {
81693       {
81694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81695       };
81696     } catch (...) {
81697       {
81698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81699       };
81700     }
81701   }
81702
81703 }
81704
81705
81706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81707   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81708   Dali::Actor arg2 ;
81709   Dali::Actor *argp2 ;
81710
81711   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81712   argp2 = (Dali::Actor *)jarg2;
81713   if (!argp2) {
81714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81715     return ;
81716   }
81717   arg2 = *argp2;
81718   {
81719     try {
81720       (arg1)->UnbindActor(arg2);
81721     } catch (std::out_of_range& e) {
81722       {
81723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81724       };
81725     } catch (std::exception& e) {
81726       {
81727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81728       };
81729     } catch (Dali::DaliException e) {
81730       {
81731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81732       };
81733     } catch (...) {
81734       {
81735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81736       };
81737     }
81738   }
81739
81740 }
81741
81742
81743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81744   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81745   Dali::Radian arg2 ;
81746   Dali::Radian arg3 ;
81747   Dali::Radian *argp2 ;
81748   Dali::Radian *argp3 ;
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   argp3 = (Dali::Radian *)jarg3;
81758   if (!argp3) {
81759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81760     return ;
81761   }
81762   arg3 = *argp3;
81763   {
81764     try {
81765       (arg1)->SetScrollingDirection(arg2,arg3);
81766     } catch (std::out_of_range& e) {
81767       {
81768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81769       };
81770     } catch (std::exception& e) {
81771       {
81772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81773       };
81774     } catch (Dali::DaliException e) {
81775       {
81776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81777       };
81778     } catch (...) {
81779       {
81780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81781       };
81782     }
81783   }
81784
81785 }
81786
81787
81788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81789   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81790   Dali::Radian arg2 ;
81791   Dali::Radian *argp2 ;
81792
81793   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81794   argp2 = (Dali::Radian *)jarg2;
81795   if (!argp2) {
81796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81797     return ;
81798   }
81799   arg2 = *argp2;
81800   {
81801     try {
81802       (arg1)->SetScrollingDirection(arg2);
81803     } catch (std::out_of_range& e) {
81804       {
81805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81806       };
81807     } catch (std::exception& e) {
81808       {
81809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81810       };
81811     } catch (Dali::DaliException e) {
81812       {
81813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81814       };
81815     } catch (...) {
81816       {
81817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81818       };
81819     }
81820   }
81821
81822 }
81823
81824
81825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81826   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81827   Dali::Radian arg2 ;
81828   Dali::Radian *argp2 ;
81829
81830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81831   argp2 = (Dali::Radian *)jarg2;
81832   if (!argp2) {
81833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81834     return ;
81835   }
81836   arg2 = *argp2;
81837   {
81838     try {
81839       (arg1)->RemoveScrollingDirection(arg2);
81840     } catch (std::out_of_range& e) {
81841       {
81842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81843       };
81844     } catch (std::exception& e) {
81845       {
81846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81847       };
81848     } catch (Dali::DaliException e) {
81849       {
81850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81851       };
81852     } catch (...) {
81853       {
81854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81855       };
81856     }
81857   }
81858
81859 }
81860
81861
81862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
81863   void * jresult ;
81864   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81865   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
81866
81867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81868   {
81869     try {
81870       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
81871     } catch (std::out_of_range& e) {
81872       {
81873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81874       };
81875     } catch (std::exception& e) {
81876       {
81877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81878       };
81879     } catch (Dali::DaliException e) {
81880       {
81881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81882       };
81883     } catch (...) {
81884       {
81885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81886       };
81887     }
81888   }
81889
81890   jresult = (void *)result;
81891   return jresult;
81892 }
81893
81894
81895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81896   int jresult ;
81897   int result;
81898
81899   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81900   jresult = (int)result;
81901   return jresult;
81902 }
81903
81904
81905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81906   int jresult ;
81907   int result;
81908
81909   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81910   jresult = (int)result;
81911   return jresult;
81912 }
81913
81914
81915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81916   int jresult ;
81917   int result;
81918
81919   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81920   jresult = (int)result;
81921   return jresult;
81922 }
81923
81924
81925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81926   int jresult ;
81927   int result;
81928
81929   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81930   jresult = (int)result;
81931   return jresult;
81932 }
81933
81934
81935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81936   int jresult ;
81937   int result;
81938
81939   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81940   jresult = (int)result;
81941   return jresult;
81942 }
81943
81944
81945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81946   void * jresult ;
81947   Dali::Toolkit::TableView::Property *result = 0 ;
81948
81949   {
81950     try {
81951       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81952     } catch (std::out_of_range& e) {
81953       {
81954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81955       };
81956     } catch (std::exception& e) {
81957       {
81958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81959       };
81960     } catch (Dali::DaliException e) {
81961       {
81962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81963       };
81964     } catch (...) {
81965       {
81966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81967       };
81968     }
81969   }
81970
81971   jresult = (void *)result;
81972   return jresult;
81973 }
81974
81975
81976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81977   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81978
81979   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81980   {
81981     try {
81982       delete arg1;
81983     } catch (std::out_of_range& e) {
81984       {
81985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81986       };
81987     } catch (std::exception& e) {
81988       {
81989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81990       };
81991     } catch (Dali::DaliException e) {
81992       {
81993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81994       };
81995     } catch (...) {
81996       {
81997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81998       };
81999     }
82000   }
82001
82002 }
82003
82004
82005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82006   int jresult ;
82007   int result;
82008
82009   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82010   jresult = (int)result;
82011   return jresult;
82012 }
82013
82014
82015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82016   int jresult ;
82017   int result;
82018
82019   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82020   jresult = (int)result;
82021   return jresult;
82022 }
82023
82024
82025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82026   int jresult ;
82027   int result;
82028
82029   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82030   jresult = (int)result;
82031   return jresult;
82032 }
82033
82034
82035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82036   int jresult ;
82037   int result;
82038
82039   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82040   jresult = (int)result;
82041   return jresult;
82042 }
82043
82044
82045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82046   int jresult ;
82047   int result;
82048
82049   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82050   jresult = (int)result;
82051   return jresult;
82052 }
82053
82054
82055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82056   void * jresult ;
82057   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82058
82059   {
82060     try {
82061       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82062     } catch (std::out_of_range& e) {
82063       {
82064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82065       };
82066     } catch (std::exception& e) {
82067       {
82068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82069       };
82070     } catch (Dali::DaliException e) {
82071       {
82072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82073       };
82074     } catch (...) {
82075       {
82076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82077       };
82078     }
82079   }
82080
82081   jresult = (void *)result;
82082   return jresult;
82083 }
82084
82085
82086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82087   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82088
82089   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82090   {
82091     try {
82092       delete arg1;
82093     } catch (std::out_of_range& e) {
82094       {
82095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82096       };
82097     } catch (std::exception& e) {
82098       {
82099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82100       };
82101     } catch (Dali::DaliException e) {
82102       {
82103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82104       };
82105     } catch (...) {
82106       {
82107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82108       };
82109     }
82110   }
82111
82112 }
82113
82114
82115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82116   void * jresult ;
82117   unsigned int arg1 ;
82118   unsigned int arg2 ;
82119   unsigned int arg3 ;
82120   unsigned int arg4 ;
82121   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82122
82123   arg1 = (unsigned int)jarg1;
82124   arg2 = (unsigned int)jarg2;
82125   arg3 = (unsigned int)jarg3;
82126   arg4 = (unsigned int)jarg4;
82127   {
82128     try {
82129       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82130     } catch (std::out_of_range& e) {
82131       {
82132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82133       };
82134     } catch (std::exception& e) {
82135       {
82136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82137       };
82138     } catch (Dali::DaliException e) {
82139       {
82140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82141       };
82142     } catch (...) {
82143       {
82144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82145       };
82146     }
82147   }
82148
82149   jresult = (void *)result;
82150   return jresult;
82151 }
82152
82153
82154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82155   void * jresult ;
82156   unsigned int arg1 ;
82157   unsigned int arg2 ;
82158   unsigned int arg3 ;
82159   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82160
82161   arg1 = (unsigned int)jarg1;
82162   arg2 = (unsigned int)jarg2;
82163   arg3 = (unsigned int)jarg3;
82164   {
82165     try {
82166       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82167     } catch (std::out_of_range& e) {
82168       {
82169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82170       };
82171     } catch (std::exception& e) {
82172       {
82173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82174       };
82175     } catch (Dali::DaliException e) {
82176       {
82177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82178       };
82179     } catch (...) {
82180       {
82181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82182       };
82183     }
82184   }
82185
82186   jresult = (void *)result;
82187   return jresult;
82188 }
82189
82190
82191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82192   void * jresult ;
82193   unsigned int arg1 ;
82194   unsigned int arg2 ;
82195   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82196
82197   arg1 = (unsigned int)jarg1;
82198   arg2 = (unsigned int)jarg2;
82199   {
82200     try {
82201       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82202     } catch (std::out_of_range& e) {
82203       {
82204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82205       };
82206     } catch (std::exception& e) {
82207       {
82208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82209       };
82210     } catch (Dali::DaliException e) {
82211       {
82212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82213       };
82214     } catch (...) {
82215       {
82216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82217       };
82218     }
82219   }
82220
82221   jresult = (void *)result;
82222   return jresult;
82223 }
82224
82225
82226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82227   void * jresult ;
82228   unsigned int arg1 ;
82229   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82230
82231   arg1 = (unsigned int)jarg1;
82232   {
82233     try {
82234       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82235     } catch (std::out_of_range& e) {
82236       {
82237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82238       };
82239     } catch (std::exception& e) {
82240       {
82241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82242       };
82243     } catch (Dali::DaliException e) {
82244       {
82245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82246       };
82247     } catch (...) {
82248       {
82249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82250       };
82251     }
82252   }
82253
82254   jresult = (void *)result;
82255   return jresult;
82256 }
82257
82258
82259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82260   void * jresult ;
82261   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82262
82263   {
82264     try {
82265       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82266     } catch (std::out_of_range& e) {
82267       {
82268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82269       };
82270     } catch (std::exception& e) {
82271       {
82272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82273       };
82274     } catch (Dali::DaliException e) {
82275       {
82276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82277       };
82278     } catch (...) {
82279       {
82280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82281       };
82282     }
82283   }
82284
82285   jresult = (void *)result;
82286   return jresult;
82287 }
82288
82289
82290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82291   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82292   unsigned int arg2 ;
82293
82294   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82295   arg2 = (unsigned int)jarg2;
82296   if (arg1) (arg1)->rowIndex = arg2;
82297 }
82298
82299
82300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82301   unsigned int jresult ;
82302   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82303   unsigned int result;
82304
82305   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82306   result = (unsigned int) ((arg1)->rowIndex);
82307   jresult = result;
82308   return jresult;
82309 }
82310
82311
82312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82313   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82314   unsigned int arg2 ;
82315
82316   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82317   arg2 = (unsigned int)jarg2;
82318   if (arg1) (arg1)->columnIndex = arg2;
82319 }
82320
82321
82322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82323   unsigned int jresult ;
82324   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82325   unsigned int result;
82326
82327   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82328   result = (unsigned int) ((arg1)->columnIndex);
82329   jresult = result;
82330   return jresult;
82331 }
82332
82333
82334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82335   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82336   unsigned int arg2 ;
82337
82338   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82339   arg2 = (unsigned int)jarg2;
82340   if (arg1) (arg1)->rowSpan = arg2;
82341 }
82342
82343
82344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82345   unsigned int jresult ;
82346   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82347   unsigned int result;
82348
82349   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82350   result = (unsigned int) ((arg1)->rowSpan);
82351   jresult = result;
82352   return jresult;
82353 }
82354
82355
82356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82357   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82358   unsigned int arg2 ;
82359
82360   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82361   arg2 = (unsigned int)jarg2;
82362   if (arg1) (arg1)->columnSpan = arg2;
82363 }
82364
82365
82366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82367   unsigned int jresult ;
82368   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82369   unsigned int result;
82370
82371   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82372   result = (unsigned int) ((arg1)->columnSpan);
82373   jresult = result;
82374   return jresult;
82375 }
82376
82377
82378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82379   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82380
82381   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82382   {
82383     try {
82384       delete arg1;
82385     } catch (std::out_of_range& e) {
82386       {
82387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82388       };
82389     } catch (std::exception& e) {
82390       {
82391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82392       };
82393     } catch (Dali::DaliException e) {
82394       {
82395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82396       };
82397     } catch (...) {
82398       {
82399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82400       };
82401     }
82402   }
82403
82404 }
82405
82406
82407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82408   void * jresult ;
82409   Dali::Toolkit::TableView *result = 0 ;
82410
82411   {
82412     try {
82413       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82414     } catch (std::out_of_range& e) {
82415       {
82416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82417       };
82418     } catch (std::exception& e) {
82419       {
82420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82421       };
82422     } catch (Dali::DaliException e) {
82423       {
82424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82425       };
82426     } catch (...) {
82427       {
82428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82429       };
82430     }
82431   }
82432
82433   jresult = (void *)result;
82434   return jresult;
82435 }
82436
82437
82438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82439   void * jresult ;
82440   Dali::Toolkit::TableView *arg1 = 0 ;
82441   Dali::Toolkit::TableView *result = 0 ;
82442
82443   arg1 = (Dali::Toolkit::TableView *)jarg1;
82444   if (!arg1) {
82445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82446     return 0;
82447   }
82448   {
82449     try {
82450       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82451     } catch (std::out_of_range& e) {
82452       {
82453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82454       };
82455     } catch (std::exception& e) {
82456       {
82457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82458       };
82459     } catch (Dali::DaliException e) {
82460       {
82461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82462       };
82463     } catch (...) {
82464       {
82465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82466       };
82467     }
82468   }
82469
82470   jresult = (void *)result;
82471   return jresult;
82472 }
82473
82474
82475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82476   void * jresult ;
82477   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82478   Dali::Toolkit::TableView *arg2 = 0 ;
82479   Dali::Toolkit::TableView *result = 0 ;
82480
82481   arg1 = (Dali::Toolkit::TableView *)jarg1;
82482   arg2 = (Dali::Toolkit::TableView *)jarg2;
82483   if (!arg2) {
82484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82485     return 0;
82486   }
82487   {
82488     try {
82489       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82490     } catch (std::out_of_range& e) {
82491       {
82492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82493       };
82494     } catch (std::exception& e) {
82495       {
82496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82497       };
82498     } catch (Dali::DaliException e) {
82499       {
82500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82501       };
82502     } catch (...) {
82503       {
82504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82505       };
82506     }
82507   }
82508
82509   jresult = (void *)result;
82510   return jresult;
82511 }
82512
82513
82514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82515   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82516
82517   arg1 = (Dali::Toolkit::TableView *)jarg1;
82518   {
82519     try {
82520       delete arg1;
82521     } catch (std::out_of_range& e) {
82522       {
82523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82524       };
82525     } catch (std::exception& e) {
82526       {
82527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82528       };
82529     } catch (Dali::DaliException e) {
82530       {
82531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82532       };
82533     } catch (...) {
82534       {
82535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82536       };
82537     }
82538   }
82539
82540 }
82541
82542
82543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82544   void * jresult ;
82545   unsigned int arg1 ;
82546   unsigned int arg2 ;
82547   Dali::Toolkit::TableView result;
82548
82549   arg1 = (unsigned int)jarg1;
82550   arg2 = (unsigned int)jarg2;
82551   {
82552     try {
82553       result = Dali::Toolkit::TableView::New(arg1,arg2);
82554     } catch (std::out_of_range& e) {
82555       {
82556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82557       };
82558     } catch (std::exception& e) {
82559       {
82560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82561       };
82562     } catch (Dali::DaliException e) {
82563       {
82564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82565       };
82566     } catch (...) {
82567       {
82568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82569       };
82570     }
82571   }
82572
82573   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82574   return jresult;
82575 }
82576
82577
82578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82579   void * jresult ;
82580   Dali::BaseHandle arg1 ;
82581   Dali::BaseHandle *argp1 ;
82582   Dali::Toolkit::TableView result;
82583
82584   argp1 = (Dali::BaseHandle *)jarg1;
82585   if (!argp1) {
82586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82587     return 0;
82588   }
82589   arg1 = *argp1;
82590   {
82591     try {
82592       result = Dali::Toolkit::TableView::DownCast(arg1);
82593     } catch (std::out_of_range& e) {
82594       {
82595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82596       };
82597     } catch (std::exception& e) {
82598       {
82599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82600       };
82601     } catch (Dali::DaliException e) {
82602       {
82603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82604       };
82605     } catch (...) {
82606       {
82607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82608       };
82609     }
82610   }
82611
82612   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82613   return jresult;
82614 }
82615
82616
82617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82618   unsigned int jresult ;
82619   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82620   Dali::Actor arg2 ;
82621   Dali::Toolkit::TableView::CellPosition arg3 ;
82622   Dali::Actor *argp2 ;
82623   Dali::Toolkit::TableView::CellPosition *argp3 ;
82624   bool result;
82625
82626   arg1 = (Dali::Toolkit::TableView *)jarg1;
82627   argp2 = (Dali::Actor *)jarg2;
82628   if (!argp2) {
82629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82630     return 0;
82631   }
82632   arg2 = *argp2;
82633   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82634   if (!argp3) {
82635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82636     return 0;
82637   }
82638   arg3 = *argp3;
82639   {
82640     try {
82641       result = (bool)(arg1)->AddChild(arg2,arg3);
82642     } catch (std::out_of_range& e) {
82643       {
82644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82645       };
82646     } catch (std::exception& e) {
82647       {
82648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82649       };
82650     } catch (Dali::DaliException e) {
82651       {
82652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82653       };
82654     } catch (...) {
82655       {
82656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82657       };
82658     }
82659   }
82660
82661   jresult = result;
82662   return jresult;
82663 }
82664
82665
82666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82667   void * jresult ;
82668   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82669   Dali::Toolkit::TableView::CellPosition arg2 ;
82670   Dali::Toolkit::TableView::CellPosition *argp2 ;
82671   Dali::Actor result;
82672
82673   arg1 = (Dali::Toolkit::TableView *)jarg1;
82674   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82675   if (!argp2) {
82676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82677     return 0;
82678   }
82679   arg2 = *argp2;
82680   {
82681     try {
82682       result = (arg1)->GetChildAt(arg2);
82683     } catch (std::out_of_range& e) {
82684       {
82685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82686       };
82687     } catch (std::exception& e) {
82688       {
82689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82690       };
82691     } catch (Dali::DaliException e) {
82692       {
82693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82694       };
82695     } catch (...) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82698       };
82699     }
82700   }
82701
82702   jresult = new Dali::Actor((const Dali::Actor &)result);
82703   return jresult;
82704 }
82705
82706
82707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82708   void * jresult ;
82709   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82710   Dali::Toolkit::TableView::CellPosition arg2 ;
82711   Dali::Toolkit::TableView::CellPosition *argp2 ;
82712   Dali::Actor result;
82713
82714   arg1 = (Dali::Toolkit::TableView *)jarg1;
82715   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82716   if (!argp2) {
82717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82718     return 0;
82719   }
82720   arg2 = *argp2;
82721   {
82722     try {
82723       result = (arg1)->RemoveChildAt(arg2);
82724     } catch (std::out_of_range& e) {
82725       {
82726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82727       };
82728     } catch (std::exception& e) {
82729       {
82730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82731       };
82732     } catch (Dali::DaliException e) {
82733       {
82734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82735       };
82736     } catch (...) {
82737       {
82738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82739       };
82740     }
82741   }
82742
82743   jresult = new Dali::Actor((const Dali::Actor &)result);
82744   return jresult;
82745 }
82746
82747
82748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82749   unsigned int jresult ;
82750   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82751   Dali::Actor arg2 ;
82752   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82753   Dali::Actor *argp2 ;
82754   bool result;
82755
82756   arg1 = (Dali::Toolkit::TableView *)jarg1;
82757   argp2 = (Dali::Actor *)jarg2;
82758   if (!argp2) {
82759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82760     return 0;
82761   }
82762   arg2 = *argp2;
82763   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82764   if (!arg3) {
82765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82766     return 0;
82767   }
82768   {
82769     try {
82770       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82771     } catch (std::out_of_range& e) {
82772       {
82773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82774       };
82775     } catch (std::exception& e) {
82776       {
82777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82778       };
82779     } catch (Dali::DaliException e) {
82780       {
82781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82782       };
82783     } catch (...) {
82784       {
82785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82786       };
82787     }
82788   }
82789
82790   jresult = result;
82791   return jresult;
82792 }
82793
82794
82795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82796   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82797   unsigned int arg2 ;
82798
82799   arg1 = (Dali::Toolkit::TableView *)jarg1;
82800   arg2 = (unsigned int)jarg2;
82801   {
82802     try {
82803       (arg1)->InsertRow(arg2);
82804     } catch (std::out_of_range& e) {
82805       {
82806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82807       };
82808     } catch (std::exception& e) {
82809       {
82810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82811       };
82812     } catch (Dali::DaliException e) {
82813       {
82814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82815       };
82816     } catch (...) {
82817       {
82818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82819       };
82820     }
82821   }
82822
82823 }
82824
82825
82826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82827   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82828   unsigned int arg2 ;
82829
82830   arg1 = (Dali::Toolkit::TableView *)jarg1;
82831   arg2 = (unsigned int)jarg2;
82832   {
82833     try {
82834       (arg1)->DeleteRow(arg2);
82835     } catch (std::out_of_range& e) {
82836       {
82837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82838       };
82839     } catch (std::exception& e) {
82840       {
82841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82842       };
82843     } catch (Dali::DaliException e) {
82844       {
82845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82846       };
82847     } catch (...) {
82848       {
82849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82850       };
82851     }
82852   }
82853
82854 }
82855
82856
82857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82858   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82859   unsigned int arg2 ;
82860   std::vector< Dali::Actor > *arg3 = 0 ;
82861
82862   arg1 = (Dali::Toolkit::TableView *)jarg1;
82863   arg2 = (unsigned int)jarg2;
82864   arg3 = (std::vector< Dali::Actor > *)jarg3;
82865   if (!arg3) {
82866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82867     return ;
82868   }
82869   {
82870     try {
82871       (arg1)->DeleteRow(arg2,*arg3);
82872     } catch (std::out_of_range& e) {
82873       {
82874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82875       };
82876     } catch (std::exception& e) {
82877       {
82878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82879       };
82880     } catch (Dali::DaliException e) {
82881       {
82882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82883       };
82884     } catch (...) {
82885       {
82886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82887       };
82888     }
82889   }
82890
82891 }
82892
82893
82894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82895   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82896   unsigned int arg2 ;
82897
82898   arg1 = (Dali::Toolkit::TableView *)jarg1;
82899   arg2 = (unsigned int)jarg2;
82900   {
82901     try {
82902       (arg1)->InsertColumn(arg2);
82903     } catch (std::out_of_range& e) {
82904       {
82905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82906       };
82907     } catch (std::exception& e) {
82908       {
82909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82910       };
82911     } catch (Dali::DaliException e) {
82912       {
82913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82914       };
82915     } catch (...) {
82916       {
82917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82918       };
82919     }
82920   }
82921
82922 }
82923
82924
82925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82926   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82927   unsigned int arg2 ;
82928
82929   arg1 = (Dali::Toolkit::TableView *)jarg1;
82930   arg2 = (unsigned int)jarg2;
82931   {
82932     try {
82933       (arg1)->DeleteColumn(arg2);
82934     } catch (std::out_of_range& e) {
82935       {
82936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82937       };
82938     } catch (std::exception& e) {
82939       {
82940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82941       };
82942     } catch (Dali::DaliException e) {
82943       {
82944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82945       };
82946     } catch (...) {
82947       {
82948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82949       };
82950     }
82951   }
82952
82953 }
82954
82955
82956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82957   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82958   unsigned int arg2 ;
82959   std::vector< Dali::Actor > *arg3 = 0 ;
82960
82961   arg1 = (Dali::Toolkit::TableView *)jarg1;
82962   arg2 = (unsigned int)jarg2;
82963   arg3 = (std::vector< Dali::Actor > *)jarg3;
82964   if (!arg3) {
82965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82966     return ;
82967   }
82968   {
82969     try {
82970       (arg1)->DeleteColumn(arg2,*arg3);
82971     } catch (std::out_of_range& e) {
82972       {
82973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82974       };
82975     } catch (std::exception& e) {
82976       {
82977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82978       };
82979     } catch (Dali::DaliException e) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82982       };
82983     } catch (...) {
82984       {
82985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82986       };
82987     }
82988   }
82989
82990 }
82991
82992
82993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82994   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82995   unsigned int arg2 ;
82996   unsigned int arg3 ;
82997
82998   arg1 = (Dali::Toolkit::TableView *)jarg1;
82999   arg2 = (unsigned int)jarg2;
83000   arg3 = (unsigned int)jarg3;
83001   {
83002     try {
83003       (arg1)->Resize(arg2,arg3);
83004     } catch (std::out_of_range& e) {
83005       {
83006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83007       };
83008     } catch (std::exception& e) {
83009       {
83010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83011       };
83012     } catch (Dali::DaliException e) {
83013       {
83014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83015       };
83016     } catch (...) {
83017       {
83018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83019       };
83020     }
83021   }
83022
83023 }
83024
83025
83026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83027   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83028   unsigned int arg2 ;
83029   unsigned int arg3 ;
83030   std::vector< Dali::Actor > *arg4 = 0 ;
83031
83032   arg1 = (Dali::Toolkit::TableView *)jarg1;
83033   arg2 = (unsigned int)jarg2;
83034   arg3 = (unsigned int)jarg3;
83035   arg4 = (std::vector< Dali::Actor > *)jarg4;
83036   if (!arg4) {
83037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83038     return ;
83039   }
83040   {
83041     try {
83042       (arg1)->Resize(arg2,arg3,*arg4);
83043     } catch (std::out_of_range& e) {
83044       {
83045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83046       };
83047     } catch (std::exception& e) {
83048       {
83049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83050       };
83051     } catch (Dali::DaliException e) {
83052       {
83053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83054       };
83055     } catch (...) {
83056       {
83057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83058       };
83059     }
83060   }
83061
83062 }
83063
83064
83065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83066   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83067   Dali::Size arg2 ;
83068   Dali::Size *argp2 ;
83069
83070   arg1 = (Dali::Toolkit::TableView *)jarg1;
83071   argp2 = (Dali::Size *)jarg2;
83072   if (!argp2) {
83073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83074     return ;
83075   }
83076   arg2 = *argp2;
83077   {
83078     try {
83079       (arg1)->SetCellPadding(arg2);
83080     } catch (std::out_of_range& e) {
83081       {
83082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83083       };
83084     } catch (std::exception& e) {
83085       {
83086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83087       };
83088     } catch (Dali::DaliException e) {
83089       {
83090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83091       };
83092     } catch (...) {
83093       {
83094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83095       };
83096     }
83097   }
83098
83099 }
83100
83101
83102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83103   void * jresult ;
83104   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83105   Dali::Size result;
83106
83107   arg1 = (Dali::Toolkit::TableView *)jarg1;
83108   {
83109     try {
83110       result = (arg1)->GetCellPadding();
83111     } catch (std::out_of_range& e) {
83112       {
83113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83114       };
83115     } catch (std::exception& e) {
83116       {
83117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83118       };
83119     } catch (Dali::DaliException e) {
83120       {
83121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83122       };
83123     } catch (...) {
83124       {
83125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83126       };
83127     }
83128   }
83129
83130   jresult = new Dali::Size((const Dali::Size &)result);
83131   return jresult;
83132 }
83133
83134
83135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83136   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83137   unsigned int arg2 ;
83138
83139   arg1 = (Dali::Toolkit::TableView *)jarg1;
83140   arg2 = (unsigned int)jarg2;
83141   {
83142     try {
83143       (arg1)->SetFitHeight(arg2);
83144     } catch (std::out_of_range& e) {
83145       {
83146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83147       };
83148     } catch (std::exception& e) {
83149       {
83150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83151       };
83152     } catch (Dali::DaliException e) {
83153       {
83154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83155       };
83156     } catch (...) {
83157       {
83158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83159       };
83160     }
83161   }
83162
83163 }
83164
83165
83166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83167   unsigned int jresult ;
83168   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83169   unsigned int arg2 ;
83170   bool result;
83171
83172   arg1 = (Dali::Toolkit::TableView *)jarg1;
83173   arg2 = (unsigned int)jarg2;
83174   {
83175     try {
83176       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83177     } catch (std::out_of_range& e) {
83178       {
83179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83180       };
83181     } catch (std::exception& e) {
83182       {
83183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83184       };
83185     } catch (Dali::DaliException e) {
83186       {
83187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83188       };
83189     } catch (...) {
83190       {
83191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83192       };
83193     }
83194   }
83195
83196   jresult = result;
83197   return jresult;
83198 }
83199
83200
83201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83202   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83203   unsigned int arg2 ;
83204
83205   arg1 = (Dali::Toolkit::TableView *)jarg1;
83206   arg2 = (unsigned int)jarg2;
83207   {
83208     try {
83209       (arg1)->SetFitWidth(arg2);
83210     } catch (std::out_of_range& e) {
83211       {
83212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83213       };
83214     } catch (std::exception& e) {
83215       {
83216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83217       };
83218     } catch (Dali::DaliException e) {
83219       {
83220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83221       };
83222     } catch (...) {
83223       {
83224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83225       };
83226     }
83227   }
83228
83229 }
83230
83231
83232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83233   unsigned int jresult ;
83234   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83235   unsigned int arg2 ;
83236   bool result;
83237
83238   arg1 = (Dali::Toolkit::TableView *)jarg1;
83239   arg2 = (unsigned int)jarg2;
83240   {
83241     try {
83242       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83243     } catch (std::out_of_range& e) {
83244       {
83245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83246       };
83247     } catch (std::exception& e) {
83248       {
83249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83250       };
83251     } catch (Dali::DaliException e) {
83252       {
83253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83254       };
83255     } catch (...) {
83256       {
83257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83258       };
83259     }
83260   }
83261
83262   jresult = result;
83263   return jresult;
83264 }
83265
83266
83267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83268   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83269   unsigned int arg2 ;
83270   float arg3 ;
83271
83272   arg1 = (Dali::Toolkit::TableView *)jarg1;
83273   arg2 = (unsigned int)jarg2;
83274   arg3 = (float)jarg3;
83275   {
83276     try {
83277       (arg1)->SetFixedHeight(arg2,arg3);
83278     } catch (std::out_of_range& e) {
83279       {
83280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83281       };
83282     } catch (std::exception& e) {
83283       {
83284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83285       };
83286     } catch (Dali::DaliException e) {
83287       {
83288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83289       };
83290     } catch (...) {
83291       {
83292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83293       };
83294     }
83295   }
83296
83297 }
83298
83299
83300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83301   float jresult ;
83302   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83303   unsigned int arg2 ;
83304   float result;
83305
83306   arg1 = (Dali::Toolkit::TableView *)jarg1;
83307   arg2 = (unsigned int)jarg2;
83308   {
83309     try {
83310       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83311     } catch (std::out_of_range& e) {
83312       {
83313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83314       };
83315     } catch (std::exception& e) {
83316       {
83317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83318       };
83319     } catch (Dali::DaliException e) {
83320       {
83321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83322       };
83323     } catch (...) {
83324       {
83325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83326       };
83327     }
83328   }
83329
83330   jresult = result;
83331   return jresult;
83332 }
83333
83334
83335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83336   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83337   unsigned int arg2 ;
83338   float arg3 ;
83339
83340   arg1 = (Dali::Toolkit::TableView *)jarg1;
83341   arg2 = (unsigned int)jarg2;
83342   arg3 = (float)jarg3;
83343   {
83344     try {
83345       (arg1)->SetRelativeHeight(arg2,arg3);
83346     } catch (std::out_of_range& e) {
83347       {
83348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83349       };
83350     } catch (std::exception& e) {
83351       {
83352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83353       };
83354     } catch (Dali::DaliException e) {
83355       {
83356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83357       };
83358     } catch (...) {
83359       {
83360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83361       };
83362     }
83363   }
83364
83365 }
83366
83367
83368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83369   float jresult ;
83370   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83371   unsigned int arg2 ;
83372   float result;
83373
83374   arg1 = (Dali::Toolkit::TableView *)jarg1;
83375   arg2 = (unsigned int)jarg2;
83376   {
83377     try {
83378       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83379     } catch (std::out_of_range& e) {
83380       {
83381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83382       };
83383     } catch (std::exception& e) {
83384       {
83385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83386       };
83387     } catch (Dali::DaliException e) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83390       };
83391     } catch (...) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83394       };
83395     }
83396   }
83397
83398   jresult = result;
83399   return jresult;
83400 }
83401
83402
83403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83404   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83405   unsigned int arg2 ;
83406   float arg3 ;
83407
83408   arg1 = (Dali::Toolkit::TableView *)jarg1;
83409   arg2 = (unsigned int)jarg2;
83410   arg3 = (float)jarg3;
83411   {
83412     try {
83413       (arg1)->SetFixedWidth(arg2,arg3);
83414     } catch (std::out_of_range& e) {
83415       {
83416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83417       };
83418     } catch (std::exception& e) {
83419       {
83420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83421       };
83422     } catch (Dali::DaliException e) {
83423       {
83424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83425       };
83426     } catch (...) {
83427       {
83428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83429       };
83430     }
83431   }
83432
83433 }
83434
83435
83436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83437   float jresult ;
83438   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83439   unsigned int arg2 ;
83440   float result;
83441
83442   arg1 = (Dali::Toolkit::TableView *)jarg1;
83443   arg2 = (unsigned int)jarg2;
83444   {
83445     try {
83446       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83447     } catch (std::out_of_range& e) {
83448       {
83449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83450       };
83451     } catch (std::exception& e) {
83452       {
83453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83454       };
83455     } catch (Dali::DaliException e) {
83456       {
83457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83458       };
83459     } catch (...) {
83460       {
83461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83462       };
83463     }
83464   }
83465
83466   jresult = result;
83467   return jresult;
83468 }
83469
83470
83471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83472   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83473   unsigned int arg2 ;
83474   float arg3 ;
83475
83476   arg1 = (Dali::Toolkit::TableView *)jarg1;
83477   arg2 = (unsigned int)jarg2;
83478   arg3 = (float)jarg3;
83479   {
83480     try {
83481       (arg1)->SetRelativeWidth(arg2,arg3);
83482     } catch (std::out_of_range& e) {
83483       {
83484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83485       };
83486     } catch (std::exception& e) {
83487       {
83488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83489       };
83490     } catch (Dali::DaliException e) {
83491       {
83492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83493       };
83494     } catch (...) {
83495       {
83496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83497       };
83498     }
83499   }
83500
83501 }
83502
83503
83504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83505   float jresult ;
83506   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83507   unsigned int arg2 ;
83508   float result;
83509
83510   arg1 = (Dali::Toolkit::TableView *)jarg1;
83511   arg2 = (unsigned int)jarg2;
83512   {
83513     try {
83514       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83515     } catch (std::out_of_range& e) {
83516       {
83517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83518       };
83519     } catch (std::exception& e) {
83520       {
83521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83522       };
83523     } catch (Dali::DaliException e) {
83524       {
83525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83526       };
83527     } catch (...) {
83528       {
83529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83530       };
83531     }
83532   }
83533
83534   jresult = result;
83535   return jresult;
83536 }
83537
83538
83539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83540   unsigned int jresult ;
83541   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83542   unsigned int result;
83543
83544   arg1 = (Dali::Toolkit::TableView *)jarg1;
83545   {
83546     try {
83547       result = (unsigned int)(arg1)->GetRows();
83548     } catch (std::out_of_range& e) {
83549       {
83550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83551       };
83552     } catch (std::exception& e) {
83553       {
83554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83555       };
83556     } catch (Dali::DaliException e) {
83557       {
83558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83559       };
83560     } catch (...) {
83561       {
83562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83563       };
83564     }
83565   }
83566
83567   jresult = result;
83568   return jresult;
83569 }
83570
83571
83572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83573   unsigned int jresult ;
83574   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83575   unsigned int result;
83576
83577   arg1 = (Dali::Toolkit::TableView *)jarg1;
83578   {
83579     try {
83580       result = (unsigned int)(arg1)->GetColumns();
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83588       };
83589     } catch (Dali::DaliException e) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83596       };
83597     }
83598   }
83599
83600   jresult = result;
83601   return jresult;
83602 }
83603
83604
83605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83606   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83607   Dali::Toolkit::TableView::CellPosition arg2 ;
83608   Dali::HorizontalAlignment::Type arg3 ;
83609   Dali::VerticalAlignment::Type arg4 ;
83610   Dali::Toolkit::TableView::CellPosition *argp2 ;
83611
83612   arg1 = (Dali::Toolkit::TableView *)jarg1;
83613   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83614   if (!argp2) {
83615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83616     return ;
83617   }
83618   arg2 = *argp2;
83619   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83620   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83621   {
83622     try {
83623       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83624     } catch (std::out_of_range& e) {
83625       {
83626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83627       };
83628     } catch (std::exception& e) {
83629       {
83630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83631       };
83632     } catch (Dali::DaliException e) {
83633       {
83634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83635       };
83636     } catch (...) {
83637       {
83638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83639       };
83640     }
83641   }
83642
83643 }
83644
83645
83646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83647   unsigned int jresult ;
83648   unsigned int result;
83649
83650   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83651   jresult = result;
83652   return jresult;
83653 }
83654
83655
83656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83657   int jresult ;
83658   int result;
83659
83660   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83661   jresult = (int)result;
83662   return jresult;
83663 }
83664
83665
83666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83667   int jresult ;
83668   int result;
83669
83670   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83671   jresult = (int)result;
83672   return jresult;
83673 }
83674
83675
83676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83677   int jresult ;
83678   int result;
83679
83680   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83681   jresult = (int)result;
83682   return jresult;
83683 }
83684
83685
83686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83687   int jresult ;
83688   int result;
83689
83690   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83691   jresult = (int)result;
83692   return jresult;
83693 }
83694
83695
83696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83697   int jresult ;
83698   int result;
83699
83700   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83701   jresult = (int)result;
83702   return jresult;
83703 }
83704
83705
83706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83707   int jresult ;
83708   int result;
83709
83710   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83711   jresult = (int)result;
83712   return jresult;
83713 }
83714
83715
83716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83717   int jresult ;
83718   int result;
83719
83720   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83721   jresult = (int)result;
83722   return jresult;
83723 }
83724
83725
83726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83727   int jresult ;
83728   int result;
83729
83730   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83731   jresult = (int)result;
83732   return jresult;
83733 }
83734
83735
83736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83737   int jresult ;
83738   int result;
83739
83740   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83741   jresult = (int)result;
83742   return jresult;
83743 }
83744
83745
83746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83747   int jresult ;
83748   int result;
83749
83750   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83751   jresult = (int)result;
83752   return jresult;
83753 }
83754
83755
83756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83757   int jresult ;
83758   int result;
83759
83760   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83761   jresult = (int)result;
83762   return jresult;
83763 }
83764
83765
83766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83767   int jresult ;
83768   int result;
83769
83770   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83771   jresult = (int)result;
83772   return jresult;
83773 }
83774
83775
83776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83777   int jresult ;
83778   int result;
83779
83780   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83781   jresult = (int)result;
83782   return jresult;
83783 }
83784
83785
83786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83787   int jresult ;
83788   int result;
83789
83790   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83791   jresult = (int)result;
83792   return jresult;
83793 }
83794
83795
83796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83797   int jresult ;
83798   int result;
83799
83800   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83801   jresult = (int)result;
83802   return jresult;
83803 }
83804
83805
83806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83807   int jresult ;
83808   int result;
83809
83810   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83811   jresult = (int)result;
83812   return jresult;
83813 }
83814
83815
83816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83817   int jresult ;
83818   int result;
83819
83820   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83821   jresult = (int)result;
83822   return jresult;
83823 }
83824
83825
83826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83827   int jresult ;
83828   int result;
83829
83830   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83831   jresult = (int)result;
83832   return jresult;
83833 }
83834
83835
83836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
83837   int jresult ;
83838   int result;
83839
83840   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
83841   jresult = (int)result;
83842   return jresult;
83843 }
83844
83845
83846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
83847   void * jresult ;
83848   Dali::Toolkit::TextLabel::Property *result = 0 ;
83849
83850   {
83851     try {
83852       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
83853     } catch (std::out_of_range& e) {
83854       {
83855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83856       };
83857     } catch (std::exception& e) {
83858       {
83859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83860       };
83861     } catch (Dali::DaliException e) {
83862       {
83863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83864       };
83865     } catch (...) {
83866       {
83867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83868       };
83869     }
83870   }
83871
83872   jresult = (void *)result;
83873   return jresult;
83874 }
83875
83876
83877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
83878   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
83879
83880   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
83881   {
83882     try {
83883       delete arg1;
83884     } catch (std::out_of_range& e) {
83885       {
83886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83887       };
83888     } catch (std::exception& e) {
83889       {
83890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83891       };
83892     } catch (Dali::DaliException e) {
83893       {
83894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83895       };
83896     } catch (...) {
83897       {
83898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83899       };
83900     }
83901   }
83902
83903 }
83904
83905
83906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83907   void * jresult ;
83908   Dali::Toolkit::TextLabel result;
83909
83910   {
83911     try {
83912       result = Dali::Toolkit::TextLabel::New();
83913     } catch (std::out_of_range& e) {
83914       {
83915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83916       };
83917     } catch (std::exception& e) {
83918       {
83919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83920       };
83921     } catch (Dali::DaliException e) {
83922       {
83923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83924       };
83925     } catch (...) {
83926       {
83927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83928       };
83929     }
83930   }
83931
83932   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83933   return jresult;
83934 }
83935
83936
83937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83938   void * jresult ;
83939   std::string *arg1 = 0 ;
83940   Dali::Toolkit::TextLabel result;
83941
83942   if (!jarg1) {
83943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83944     return 0;
83945   }
83946   std::string arg1_str(jarg1);
83947   arg1 = &arg1_str;
83948   {
83949     try {
83950       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83951     } catch (std::out_of_range& e) {
83952       {
83953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83954       };
83955     } catch (std::exception& e) {
83956       {
83957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83958       };
83959     } catch (Dali::DaliException e) {
83960       {
83961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83962       };
83963     } catch (...) {
83964       {
83965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83966       };
83967     }
83968   }
83969
83970   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83971
83972   //argout typemap for const std::string&
83973
83974   return jresult;
83975 }
83976
83977
83978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83979   void * jresult ;
83980   Dali::Toolkit::TextLabel *result = 0 ;
83981
83982   {
83983     try {
83984       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83985     } catch (std::out_of_range& e) {
83986       {
83987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83988       };
83989     } catch (std::exception& e) {
83990       {
83991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83992       };
83993     } catch (Dali::DaliException e) {
83994       {
83995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83996       };
83997     } catch (...) {
83998       {
83999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84000       };
84001     }
84002   }
84003
84004   jresult = (void *)result;
84005   return jresult;
84006 }
84007
84008
84009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84010   void * jresult ;
84011   Dali::Toolkit::TextLabel *arg1 = 0 ;
84012   Dali::Toolkit::TextLabel *result = 0 ;
84013
84014   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84015   if (!arg1) {
84016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84017     return 0;
84018   }
84019   {
84020     try {
84021       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84022     } catch (std::out_of_range& e) {
84023       {
84024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84025       };
84026     } catch (std::exception& e) {
84027       {
84028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84029       };
84030     } catch (Dali::DaliException e) {
84031       {
84032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84033       };
84034     } catch (...) {
84035       {
84036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84037       };
84038     }
84039   }
84040
84041   jresult = (void *)result;
84042   return jresult;
84043 }
84044
84045
84046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84047   void * jresult ;
84048   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84049   Dali::Toolkit::TextLabel *arg2 = 0 ;
84050   Dali::Toolkit::TextLabel *result = 0 ;
84051
84052   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84053   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84054   if (!arg2) {
84055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84056     return 0;
84057   }
84058   {
84059     try {
84060       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84061     } catch (std::out_of_range& e) {
84062       {
84063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84064       };
84065     } catch (std::exception& e) {
84066       {
84067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84068       };
84069     } catch (Dali::DaliException e) {
84070       {
84071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84072       };
84073     } catch (...) {
84074       {
84075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84076       };
84077     }
84078   }
84079
84080   jresult = (void *)result;
84081   return jresult;
84082 }
84083
84084
84085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84086   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84087
84088   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84089   {
84090     try {
84091       delete arg1;
84092     } catch (std::out_of_range& e) {
84093       {
84094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84095       };
84096     } catch (std::exception& e) {
84097       {
84098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84099       };
84100     } catch (Dali::DaliException e) {
84101       {
84102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84103       };
84104     } catch (...) {
84105       {
84106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84107       };
84108     }
84109   }
84110
84111 }
84112
84113
84114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84115   void * jresult ;
84116   Dali::BaseHandle arg1 ;
84117   Dali::BaseHandle *argp1 ;
84118   Dali::Toolkit::TextLabel result;
84119
84120   argp1 = (Dali::BaseHandle *)jarg1;
84121   if (!argp1) {
84122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84123     return 0;
84124   }
84125   arg1 = *argp1;
84126   {
84127     try {
84128       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84129     } catch (std::out_of_range& e) {
84130       {
84131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84132       };
84133     } catch (std::exception& e) {
84134       {
84135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84136       };
84137     } catch (Dali::DaliException e) {
84138       {
84139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84140       };
84141     } catch (...) {
84142       {
84143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84144       };
84145     }
84146   }
84147
84148   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84149   return jresult;
84150 }
84151
84152
84153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84154   void * jresult ;
84155   Dali::Toolkit::AccessibilityManager *result = 0 ;
84156
84157   {
84158     try {
84159       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84160     } catch (std::out_of_range& e) {
84161       {
84162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84163       };
84164     } catch (std::exception& e) {
84165       {
84166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84167       };
84168     } catch (Dali::DaliException e) {
84169       {
84170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84171       };
84172     } catch (...) {
84173       {
84174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84175       };
84176     }
84177   }
84178
84179   jresult = (void *)result;
84180   return jresult;
84181 }
84182
84183
84184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84186
84187   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84188   {
84189     try {
84190       delete arg1;
84191     } catch (std::out_of_range& e) {
84192       {
84193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84194       };
84195     } catch (std::exception& e) {
84196       {
84197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84198       };
84199     } catch (Dali::DaliException e) {
84200       {
84201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84202       };
84203     } catch (...) {
84204       {
84205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84206       };
84207     }
84208   }
84209
84210 }
84211
84212
84213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84214   void * jresult ;
84215   Dali::Toolkit::AccessibilityManager result;
84216
84217   {
84218     try {
84219       result = Dali::Toolkit::AccessibilityManager::Get();
84220     } catch (std::out_of_range& e) {
84221       {
84222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84223       };
84224     } catch (std::exception& e) {
84225       {
84226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84227       };
84228     } catch (Dali::DaliException e) {
84229       {
84230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84231       };
84232     } catch (...) {
84233       {
84234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84235       };
84236     }
84237   }
84238
84239   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84240   return jresult;
84241 }
84242
84243
84244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84245   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84246   Dali::Actor arg2 ;
84247   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84248   std::string *arg4 = 0 ;
84249   Dali::Actor *argp2 ;
84250
84251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84252   argp2 = (Dali::Actor *)jarg2;
84253   if (!argp2) {
84254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84255     return ;
84256   }
84257   arg2 = *argp2;
84258   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84259   if (!jarg4) {
84260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84261     return ;
84262   }
84263   std::string arg4_str(jarg4);
84264   arg4 = &arg4_str;
84265   {
84266     try {
84267       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84268     } catch (std::out_of_range& e) {
84269       {
84270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84271       };
84272     } catch (std::exception& e) {
84273       {
84274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84275       };
84276     } catch (Dali::DaliException e) {
84277       {
84278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84279       };
84280     } catch (...) {
84281       {
84282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84283       };
84284     }
84285   }
84286
84287
84288   //argout typemap for const std::string&
84289
84290 }
84291
84292
84293 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84294   char * jresult ;
84295   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84296   Dali::Actor arg2 ;
84297   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84298   Dali::Actor *argp2 ;
84299   std::string result;
84300
84301   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84302   argp2 = (Dali::Actor *)jarg2;
84303   if (!argp2) {
84304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84305     return 0;
84306   }
84307   arg2 = *argp2;
84308   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84309   {
84310     try {
84311       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84312     } catch (std::out_of_range& e) {
84313       {
84314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84315       };
84316     } catch (std::exception& e) {
84317       {
84318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84319       };
84320     } catch (Dali::DaliException e) {
84321       {
84322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84323       };
84324     } catch (...) {
84325       {
84326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84327       };
84328     }
84329   }
84330
84331   jresult = SWIG_csharp_string_callback((&result)->c_str());
84332   return jresult;
84333 }
84334
84335
84336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84337   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84338   Dali::Actor arg2 ;
84339   unsigned int arg3 ;
84340   Dali::Actor *argp2 ;
84341
84342   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84343   argp2 = (Dali::Actor *)jarg2;
84344   if (!argp2) {
84345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84346     return ;
84347   }
84348   arg2 = *argp2;
84349   arg3 = (unsigned int)jarg3;
84350   {
84351     try {
84352       (arg1)->SetFocusOrder(arg2,arg3);
84353     } catch (std::out_of_range& e) {
84354       {
84355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84356       };
84357     } catch (std::exception& e) {
84358       {
84359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84360       };
84361     } catch (Dali::DaliException e) {
84362       {
84363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84364       };
84365     } catch (...) {
84366       {
84367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84368       };
84369     }
84370   }
84371
84372 }
84373
84374
84375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84376   unsigned int jresult ;
84377   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84378   Dali::Actor arg2 ;
84379   Dali::Actor *argp2 ;
84380   unsigned int result;
84381
84382   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84383   argp2 = (Dali::Actor *)jarg2;
84384   if (!argp2) {
84385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84386     return 0;
84387   }
84388   arg2 = *argp2;
84389   {
84390     try {
84391       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84392     } catch (std::out_of_range& e) {
84393       {
84394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84395       };
84396     } catch (std::exception& e) {
84397       {
84398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84399       };
84400     } catch (Dali::DaliException e) {
84401       {
84402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84403       };
84404     } catch (...) {
84405       {
84406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84407       };
84408     }
84409   }
84410
84411   jresult = result;
84412   return jresult;
84413 }
84414
84415
84416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84417   unsigned int jresult ;
84418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84419   unsigned int result;
84420
84421   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84422   {
84423     try {
84424       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84425     } catch (std::out_of_range& e) {
84426       {
84427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84428       };
84429     } catch (std::exception& e) {
84430       {
84431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84432       };
84433     } catch (Dali::DaliException e) {
84434       {
84435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84436       };
84437     } catch (...) {
84438       {
84439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84440       };
84441     }
84442   }
84443
84444   jresult = result;
84445   return jresult;
84446 }
84447
84448
84449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84450   void * jresult ;
84451   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84452   unsigned int arg2 ;
84453   Dali::Actor result;
84454
84455   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84456   arg2 = (unsigned int)jarg2;
84457   {
84458     try {
84459       result = (arg1)->GetActorByFocusOrder(arg2);
84460     } catch (std::out_of_range& e) {
84461       {
84462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84463       };
84464     } catch (std::exception& e) {
84465       {
84466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84467       };
84468     } catch (Dali::DaliException e) {
84469       {
84470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84471       };
84472     } catch (...) {
84473       {
84474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84475       };
84476     }
84477   }
84478
84479   jresult = new Dali::Actor((const Dali::Actor &)result);
84480   return jresult;
84481 }
84482
84483
84484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84485   unsigned int jresult ;
84486   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84487   Dali::Actor arg2 ;
84488   Dali::Actor *argp2 ;
84489   bool result;
84490
84491   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84492   argp2 = (Dali::Actor *)jarg2;
84493   if (!argp2) {
84494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84495     return 0;
84496   }
84497   arg2 = *argp2;
84498   {
84499     try {
84500       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84501     } catch (std::out_of_range& e) {
84502       {
84503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84504       };
84505     } catch (std::exception& e) {
84506       {
84507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84508       };
84509     } catch (Dali::DaliException e) {
84510       {
84511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84512       };
84513     } catch (...) {
84514       {
84515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84516       };
84517     }
84518   }
84519
84520   jresult = result;
84521   return jresult;
84522 }
84523
84524
84525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84526   void * jresult ;
84527   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84528   Dali::Actor result;
84529
84530   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84531   {
84532     try {
84533       result = (arg1)->GetCurrentFocusActor();
84534     } catch (std::out_of_range& e) {
84535       {
84536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84537       };
84538     } catch (std::exception& e) {
84539       {
84540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84541       };
84542     } catch (Dali::DaliException e) {
84543       {
84544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84545       };
84546     } catch (...) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84549       };
84550     }
84551   }
84552
84553   jresult = new Dali::Actor((const Dali::Actor &)result);
84554   return jresult;
84555 }
84556
84557
84558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84559   void * jresult ;
84560   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84561   Dali::Actor result;
84562
84563   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84564   {
84565     try {
84566       result = (arg1)->GetCurrentFocusGroup();
84567     } catch (std::out_of_range& e) {
84568       {
84569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84570       };
84571     } catch (std::exception& e) {
84572       {
84573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84574       };
84575     } catch (Dali::DaliException e) {
84576       {
84577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84578       };
84579     } catch (...) {
84580       {
84581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84582       };
84583     }
84584   }
84585
84586   jresult = new Dali::Actor((const Dali::Actor &)result);
84587   return jresult;
84588 }
84589
84590
84591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84592   unsigned int jresult ;
84593   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84594   unsigned int result;
84595
84596   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84597   {
84598     try {
84599       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84600     } catch (std::out_of_range& e) {
84601       {
84602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84603       };
84604     } catch (std::exception& e) {
84605       {
84606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84607       };
84608     } catch (Dali::DaliException e) {
84609       {
84610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84611       };
84612     } catch (...) {
84613       {
84614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84615       };
84616     }
84617   }
84618
84619   jresult = result;
84620   return jresult;
84621 }
84622
84623
84624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84625   unsigned int jresult ;
84626   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84627   bool result;
84628
84629   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84630   {
84631     try {
84632       result = (bool)(arg1)->MoveFocusForward();
84633     } catch (std::out_of_range& e) {
84634       {
84635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84636       };
84637     } catch (std::exception& e) {
84638       {
84639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84640       };
84641     } catch (Dali::DaliException e) {
84642       {
84643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84644       };
84645     } catch (...) {
84646       {
84647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84648       };
84649     }
84650   }
84651
84652   jresult = result;
84653   return jresult;
84654 }
84655
84656
84657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84658   unsigned int jresult ;
84659   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84660   bool result;
84661
84662   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84663   {
84664     try {
84665       result = (bool)(arg1)->MoveFocusBackward();
84666     } catch (std::out_of_range& e) {
84667       {
84668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84669       };
84670     } catch (std::exception& e) {
84671       {
84672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84673       };
84674     } catch (Dali::DaliException e) {
84675       {
84676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84677       };
84678     } catch (...) {
84679       {
84680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84681       };
84682     }
84683   }
84684
84685   jresult = result;
84686   return jresult;
84687 }
84688
84689
84690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84691   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84692
84693   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84694   {
84695     try {
84696       (arg1)->ClearFocus();
84697     } catch (std::out_of_range& e) {
84698       {
84699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84700       };
84701     } catch (std::exception& e) {
84702       {
84703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84704       };
84705     } catch (Dali::DaliException e) {
84706       {
84707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84708       };
84709     } catch (...) {
84710       {
84711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84712       };
84713     }
84714   }
84715
84716 }
84717
84718
84719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84721
84722   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84723   {
84724     try {
84725       (arg1)->Reset();
84726     } catch (std::out_of_range& e) {
84727       {
84728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84729       };
84730     } catch (std::exception& e) {
84731       {
84732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84733       };
84734     } catch (Dali::DaliException e) {
84735       {
84736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84737       };
84738     } catch (...) {
84739       {
84740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84741       };
84742     }
84743   }
84744
84745 }
84746
84747
84748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84749   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84750   Dali::Actor arg2 ;
84751   bool arg3 ;
84752   Dali::Actor *argp2 ;
84753
84754   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84755   argp2 = (Dali::Actor *)jarg2;
84756   if (!argp2) {
84757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84758     return ;
84759   }
84760   arg2 = *argp2;
84761   arg3 = jarg3 ? true : false;
84762   {
84763     try {
84764       (arg1)->SetFocusGroup(arg2,arg3);
84765     } catch (std::out_of_range& e) {
84766       {
84767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84768       };
84769     } catch (std::exception& e) {
84770       {
84771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84772       };
84773     } catch (Dali::DaliException e) {
84774       {
84775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84776       };
84777     } catch (...) {
84778       {
84779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84780       };
84781     }
84782   }
84783
84784 }
84785
84786
84787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84788   unsigned int jresult ;
84789   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84790   Dali::Actor arg2 ;
84791   Dali::Actor *argp2 ;
84792   bool result;
84793
84794   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84795   argp2 = (Dali::Actor *)jarg2;
84796   if (!argp2) {
84797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84798     return 0;
84799   }
84800   arg2 = *argp2;
84801   {
84802     try {
84803       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84804     } catch (std::out_of_range& e) {
84805       {
84806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84807       };
84808     } catch (std::exception& e) {
84809       {
84810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84811       };
84812     } catch (Dali::DaliException e) {
84813       {
84814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84815       };
84816     } catch (...) {
84817       {
84818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84819       };
84820     }
84821   }
84822
84823   jresult = result;
84824   return jresult;
84825 }
84826
84827
84828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84829   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84830   bool arg2 ;
84831
84832   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84833   arg2 = jarg2 ? true : false;
84834   {
84835     try {
84836       (arg1)->SetGroupMode(arg2);
84837     } catch (std::out_of_range& e) {
84838       {
84839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84840       };
84841     } catch (std::exception& e) {
84842       {
84843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84844       };
84845     } catch (Dali::DaliException e) {
84846       {
84847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84848       };
84849     } catch (...) {
84850       {
84851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84852       };
84853     }
84854   }
84855
84856 }
84857
84858
84859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
84860   unsigned int jresult ;
84861   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84862   bool result;
84863
84864   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84865   {
84866     try {
84867       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
84868     } catch (std::out_of_range& e) {
84869       {
84870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84871       };
84872     } catch (std::exception& e) {
84873       {
84874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84875       };
84876     } catch (Dali::DaliException e) {
84877       {
84878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84879       };
84880     } catch (...) {
84881       {
84882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84883       };
84884     }
84885   }
84886
84887   jresult = result;
84888   return jresult;
84889 }
84890
84891
84892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84893   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84894   bool arg2 ;
84895
84896   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84897   arg2 = jarg2 ? true : false;
84898   {
84899     try {
84900       (arg1)->SetWrapMode(arg2);
84901     } catch (std::out_of_range& e) {
84902       {
84903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84904       };
84905     } catch (std::exception& e) {
84906       {
84907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84908       };
84909     } catch (Dali::DaliException e) {
84910       {
84911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84912       };
84913     } catch (...) {
84914       {
84915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84916       };
84917     }
84918   }
84919
84920 }
84921
84922
84923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84924   unsigned int jresult ;
84925   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84926   bool result;
84927
84928   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84929   {
84930     try {
84931       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84932     } catch (std::out_of_range& e) {
84933       {
84934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84935       };
84936     } catch (std::exception& e) {
84937       {
84938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84939       };
84940     } catch (Dali::DaliException e) {
84941       {
84942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84943       };
84944     } catch (...) {
84945       {
84946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84947       };
84948     }
84949   }
84950
84951   jresult = result;
84952   return jresult;
84953 }
84954
84955
84956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84957   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84958   Dali::Actor arg2 ;
84959   Dali::Actor *argp2 ;
84960
84961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84962   argp2 = (Dali::Actor *)jarg2;
84963   if (!argp2) {
84964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84965     return ;
84966   }
84967   arg2 = *argp2;
84968   {
84969     try {
84970       (arg1)->SetFocusIndicatorActor(arg2);
84971     } catch (std::out_of_range& e) {
84972       {
84973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84974       };
84975     } catch (std::exception& e) {
84976       {
84977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84978       };
84979     } catch (Dali::DaliException e) {
84980       {
84981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84982       };
84983     } catch (...) {
84984       {
84985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84986       };
84987     }
84988   }
84989
84990 }
84991
84992
84993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84994   void * jresult ;
84995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84996   Dali::Actor result;
84997
84998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84999   {
85000     try {
85001       result = (arg1)->GetFocusIndicatorActor();
85002     } catch (std::out_of_range& e) {
85003       {
85004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85005       };
85006     } catch (std::exception& e) {
85007       {
85008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85009       };
85010     } catch (Dali::DaliException e) {
85011       {
85012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85013       };
85014     } catch (...) {
85015       {
85016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85017       };
85018     }
85019   }
85020
85021   jresult = new Dali::Actor((const Dali::Actor &)result);
85022   return jresult;
85023 }
85024
85025
85026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85027   void * jresult ;
85028   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85029   Dali::Actor arg2 ;
85030   Dali::Actor *argp2 ;
85031   Dali::Actor result;
85032
85033   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85034   argp2 = (Dali::Actor *)jarg2;
85035   if (!argp2) {
85036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85037     return 0;
85038   }
85039   arg2 = *argp2;
85040   {
85041     try {
85042       result = (arg1)->GetFocusGroup(arg2);
85043     } catch (std::out_of_range& e) {
85044       {
85045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85046       };
85047     } catch (std::exception& e) {
85048       {
85049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85050       };
85051     } catch (Dali::DaliException e) {
85052       {
85053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85054       };
85055     } catch (...) {
85056       {
85057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85058       };
85059     }
85060   }
85061
85062   jresult = new Dali::Actor((const Dali::Actor &)result);
85063   return jresult;
85064 }
85065
85066
85067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85068   void * jresult ;
85069   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85070   Dali::Vector2 result;
85071
85072   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85073   {
85074     try {
85075       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85076     } catch (std::out_of_range& e) {
85077       {
85078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85079       };
85080     } catch (std::exception& e) {
85081       {
85082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85083       };
85084     } catch (Dali::DaliException e) {
85085       {
85086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85087       };
85088     } catch (...) {
85089       {
85090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85091       };
85092     }
85093   }
85094
85095   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85096   return jresult;
85097 }
85098
85099
85100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85101   void * jresult ;
85102   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85103   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85104
85105   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85106   {
85107     try {
85108       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85109     } catch (std::out_of_range& e) {
85110       {
85111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85112       };
85113     } catch (std::exception& e) {
85114       {
85115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85116       };
85117     } catch (Dali::DaliException e) {
85118       {
85119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85120       };
85121     } catch (...) {
85122       {
85123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85124       };
85125     }
85126   }
85127
85128   jresult = (void *)result;
85129   return jresult;
85130 }
85131
85132
85133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85134   void * jresult ;
85135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85136   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85137
85138   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85139   {
85140     try {
85141       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85142     } catch (std::out_of_range& e) {
85143       {
85144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85145       };
85146     } catch (std::exception& e) {
85147       {
85148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85149       };
85150     } catch (Dali::DaliException e) {
85151       {
85152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85153       };
85154     } catch (...) {
85155       {
85156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85157       };
85158     }
85159   }
85160
85161   jresult = (void *)result;
85162   return jresult;
85163 }
85164
85165
85166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85167   void * jresult ;
85168   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85169   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85170
85171   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85172   {
85173     try {
85174       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85175     } catch (std::out_of_range& e) {
85176       {
85177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85178       };
85179     } catch (std::exception& e) {
85180       {
85181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85182       };
85183     } catch (Dali::DaliException e) {
85184       {
85185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85186       };
85187     } catch (...) {
85188       {
85189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85190       };
85191     }
85192   }
85193
85194   jresult = (void *)result;
85195   return jresult;
85196 }
85197
85198
85199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85200   void * jresult ;
85201   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85202   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85203
85204   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85205   {
85206     try {
85207       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85208     } catch (std::out_of_range& e) {
85209       {
85210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85211       };
85212     } catch (std::exception& e) {
85213       {
85214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85215       };
85216     } catch (Dali::DaliException e) {
85217       {
85218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85219       };
85220     } catch (...) {
85221       {
85222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85223       };
85224     }
85225   }
85226
85227   jresult = (void *)result;
85228   return jresult;
85229 }
85230
85231
85232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85233   void * jresult ;
85234   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85235   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85236
85237   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85238   {
85239     try {
85240       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85241     } catch (std::out_of_range& e) {
85242       {
85243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85244       };
85245     } catch (std::exception& e) {
85246       {
85247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85248       };
85249     } catch (Dali::DaliException e) {
85250       {
85251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85252       };
85253     } catch (...) {
85254       {
85255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85256       };
85257     }
85258   }
85259
85260   jresult = (void *)result;
85261   return jresult;
85262 }
85263
85264
85265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85266   void * jresult ;
85267   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85268   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85269
85270   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85271   {
85272     try {
85273       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85274     } catch (std::out_of_range& e) {
85275       {
85276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85277       };
85278     } catch (std::exception& e) {
85279       {
85280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85281       };
85282     } catch (Dali::DaliException e) {
85283       {
85284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85285       };
85286     } catch (...) {
85287       {
85288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85289       };
85290     }
85291   }
85292
85293   jresult = (void *)result;
85294   return jresult;
85295 }
85296
85297
85298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85299   void * jresult ;
85300   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85301   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85302
85303   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85304   {
85305     try {
85306       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85307     } catch (std::out_of_range& e) {
85308       {
85309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85310       };
85311     } catch (std::exception& e) {
85312       {
85313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85314       };
85315     } catch (Dali::DaliException e) {
85316       {
85317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85318       };
85319     } catch (...) {
85320       {
85321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85322       };
85323     }
85324   }
85325
85326   jresult = (void *)result;
85327   return jresult;
85328 }
85329
85330
85331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85332   void * jresult ;
85333   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85334   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85335
85336   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85337   {
85338     try {
85339       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85340     } catch (std::out_of_range& e) {
85341       {
85342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85343       };
85344     } catch (std::exception& e) {
85345       {
85346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85347       };
85348     } catch (Dali::DaliException e) {
85349       {
85350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85351       };
85352     } catch (...) {
85353       {
85354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85355       };
85356     }
85357   }
85358
85359   jresult = (void *)result;
85360   return jresult;
85361 }
85362
85363
85364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85365   void * jresult ;
85366   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85367   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85368
85369   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85370   {
85371     try {
85372       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85373     } catch (std::out_of_range& e) {
85374       {
85375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85376       };
85377     } catch (std::exception& e) {
85378       {
85379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85380       };
85381     } catch (Dali::DaliException e) {
85382       {
85383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85384       };
85385     } catch (...) {
85386       {
85387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85388       };
85389     }
85390   }
85391
85392   jresult = (void *)result;
85393   return jresult;
85394 }
85395
85396
85397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85398   void * jresult ;
85399   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85400   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85401
85402   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85403   {
85404     try {
85405       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85406     } catch (std::out_of_range& e) {
85407       {
85408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85409       };
85410     } catch (std::exception& e) {
85411       {
85412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85413       };
85414     } catch (Dali::DaliException e) {
85415       {
85416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85417       };
85418     } catch (...) {
85419       {
85420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85421       };
85422     }
85423   }
85424
85425   jresult = (void *)result;
85426   return jresult;
85427 }
85428
85429
85430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85431   void * jresult ;
85432   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85433   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85434
85435   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85436   {
85437     try {
85438       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85439     } catch (std::out_of_range& e) {
85440       {
85441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85442       };
85443     } catch (std::exception& e) {
85444       {
85445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85446       };
85447     } catch (Dali::DaliException e) {
85448       {
85449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85450       };
85451     } catch (...) {
85452       {
85453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85454       };
85455     }
85456   }
85457
85458   jresult = (void *)result;
85459   return jresult;
85460 }
85461
85462
85463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85464   void * jresult ;
85465   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85466   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85467
85468   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85469   {
85470     try {
85471       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85472     } catch (std::out_of_range& e) {
85473       {
85474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85475       };
85476     } catch (std::exception& e) {
85477       {
85478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85479       };
85480     } catch (Dali::DaliException e) {
85481       {
85482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85483       };
85484     } catch (...) {
85485       {
85486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85487       };
85488     }
85489   }
85490
85491   jresult = (void *)result;
85492   return jresult;
85493 }
85494
85495
85496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85497   void * jresult ;
85498   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85499   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85500
85501   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85502   {
85503     try {
85504       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85505     } catch (std::out_of_range& e) {
85506       {
85507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85508       };
85509     } catch (std::exception& e) {
85510       {
85511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85512       };
85513     } catch (Dali::DaliException e) {
85514       {
85515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85516       };
85517     } catch (...) {
85518       {
85519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85520       };
85521     }
85522   }
85523
85524   jresult = (void *)result;
85525   return jresult;
85526 }
85527
85528
85529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85530   void * jresult ;
85531   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85532   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85533
85534   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85535   {
85536     try {
85537       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85538     } catch (std::out_of_range& e) {
85539       {
85540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85541       };
85542     } catch (std::exception& e) {
85543       {
85544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85545       };
85546     } catch (Dali::DaliException e) {
85547       {
85548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85549       };
85550     } catch (...) {
85551       {
85552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85553       };
85554     }
85555   }
85556
85557   jresult = (void *)result;
85558   return jresult;
85559 }
85560
85561
85562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85563   void * jresult ;
85564   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85565   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85566
85567   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85568   {
85569     try {
85570       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85571     } catch (std::out_of_range& e) {
85572       {
85573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85574       };
85575     } catch (std::exception& e) {
85576       {
85577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85578       };
85579     } catch (Dali::DaliException e) {
85580       {
85581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85582       };
85583     } catch (...) {
85584       {
85585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85586       };
85587     }
85588   }
85589
85590   jresult = (void *)result;
85591   return jresult;
85592 }
85593
85594
85595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85596   void * jresult ;
85597   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85598   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85599
85600   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85601   {
85602     try {
85603       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85604     } catch (std::out_of_range& e) {
85605       {
85606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85607       };
85608     } catch (std::exception& e) {
85609       {
85610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85611       };
85612     } catch (Dali::DaliException e) {
85613       {
85614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85615       };
85616     } catch (...) {
85617       {
85618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85619       };
85620     }
85621   }
85622
85623   jresult = (void *)result;
85624   return jresult;
85625 }
85626
85627
85628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85629   void * jresult ;
85630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85631   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85632
85633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85634   {
85635     try {
85636       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85637     } catch (std::out_of_range& e) {
85638       {
85639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85640       };
85641     } catch (std::exception& e) {
85642       {
85643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85644       };
85645     } catch (Dali::DaliException e) {
85646       {
85647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85648       };
85649     } catch (...) {
85650       {
85651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85652       };
85653     }
85654   }
85655
85656   jresult = (void *)result;
85657   return jresult;
85658 }
85659
85660
85661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85662   void * jresult ;
85663   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85664   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85665
85666   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85667   {
85668     try {
85669       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85670     } catch (std::out_of_range& e) {
85671       {
85672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85673       };
85674     } catch (std::exception& e) {
85675       {
85676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85677       };
85678     } catch (Dali::DaliException e) {
85679       {
85680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85681       };
85682     } catch (...) {
85683       {
85684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85685       };
85686     }
85687   }
85688
85689   jresult = (void *)result;
85690   return jresult;
85691 }
85692
85693
85694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85695   void * jresult ;
85696   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85697   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85698
85699   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85700   {
85701     try {
85702       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85703     } catch (std::out_of_range& e) {
85704       {
85705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85706       };
85707     } catch (std::exception& e) {
85708       {
85709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85710       };
85711     } catch (Dali::DaliException e) {
85712       {
85713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85714       };
85715     } catch (...) {
85716       {
85717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85718       };
85719     }
85720   }
85721
85722   jresult = (void *)result;
85723   return jresult;
85724 }
85725
85726
85727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85728   void * jresult ;
85729   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85730   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85731
85732   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85733   {
85734     try {
85735       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85736     } catch (std::out_of_range& e) {
85737       {
85738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85739       };
85740     } catch (std::exception& e) {
85741       {
85742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85743       };
85744     } catch (Dali::DaliException e) {
85745       {
85746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85747       };
85748     } catch (...) {
85749       {
85750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85751       };
85752     }
85753   }
85754
85755   jresult = (void *)result;
85756   return jresult;
85757 }
85758
85759
85760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85761   void * jresult ;
85762   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85763   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85764
85765   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85766   {
85767     try {
85768       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85769     } catch (std::out_of_range& e) {
85770       {
85771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85772       };
85773     } catch (std::exception& e) {
85774       {
85775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85776       };
85777     } catch (Dali::DaliException e) {
85778       {
85779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85780       };
85781     } catch (...) {
85782       {
85783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85784       };
85785     }
85786   }
85787
85788   jresult = (void *)result;
85789   return jresult;
85790 }
85791
85792
85793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85794   void * jresult ;
85795   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85796   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85797
85798   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85799   {
85800     try {
85801       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85802     } catch (std::out_of_range& e) {
85803       {
85804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85805       };
85806     } catch (std::exception& e) {
85807       {
85808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85809       };
85810     } catch (Dali::DaliException e) {
85811       {
85812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85813       };
85814     } catch (...) {
85815       {
85816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85817       };
85818     }
85819   }
85820
85821   jresult = (void *)result;
85822   return jresult;
85823 }
85824
85825
85826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85827   void * jresult ;
85828   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85829   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85830
85831   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85832   {
85833     try {
85834       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
85835     } catch (std::out_of_range& e) {
85836       {
85837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85838       };
85839     } catch (std::exception& e) {
85840       {
85841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85842       };
85843     } catch (Dali::DaliException e) {
85844       {
85845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85846       };
85847     } catch (...) {
85848       {
85849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85850       };
85851     }
85852   }
85853
85854   jresult = (void *)result;
85855   return jresult;
85856 }
85857
85858
85859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
85860   void * jresult ;
85861   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85862   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85863
85864   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85865   {
85866     try {
85867       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
85868     } catch (std::out_of_range& e) {
85869       {
85870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85871       };
85872     } catch (std::exception& e) {
85873       {
85874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85875       };
85876     } catch (Dali::DaliException e) {
85877       {
85878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85879       };
85880     } catch (...) {
85881       {
85882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85883       };
85884     }
85885   }
85886
85887   jresult = (void *)result;
85888   return jresult;
85889 }
85890
85891
85892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85893   void * jresult ;
85894   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85895   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85896
85897   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85898   {
85899     try {
85900       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85901     } catch (std::out_of_range& e) {
85902       {
85903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85904       };
85905     } catch (std::exception& e) {
85906       {
85907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85908       };
85909     } catch (Dali::DaliException e) {
85910       {
85911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85912       };
85913     } catch (...) {
85914       {
85915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85916       };
85917     }
85918   }
85919
85920   jresult = (void *)result;
85921   return jresult;
85922 }
85923
85924
85925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85926   void * jresult ;
85927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85928   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85929
85930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85931   {
85932     try {
85933       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85934     } catch (std::out_of_range& e) {
85935       {
85936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85937       };
85938     } catch (std::exception& e) {
85939       {
85940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85941       };
85942     } catch (Dali::DaliException e) {
85943       {
85944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85945       };
85946     } catch (...) {
85947       {
85948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85949       };
85950     }
85951   }
85952
85953   jresult = (void *)result;
85954   return jresult;
85955 }
85956
85957
85958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85959   void * jresult ;
85960   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85961   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85962
85963   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85964   {
85965     try {
85966       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85967     } catch (std::out_of_range& e) {
85968       {
85969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85970       };
85971     } catch (std::exception& e) {
85972       {
85973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85974       };
85975     } catch (Dali::DaliException e) {
85976       {
85977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85978       };
85979     } catch (...) {
85980       {
85981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85982       };
85983     }
85984   }
85985
85986   jresult = (void *)result;
85987   return jresult;
85988 }
85989
85990
85991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85992   void * jresult ;
85993   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85994   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85995
85996   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85997   {
85998     try {
85999       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86000     } catch (std::out_of_range& e) {
86001       {
86002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86003       };
86004     } catch (std::exception& e) {
86005       {
86006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86007       };
86008     } catch (Dali::DaliException e) {
86009       {
86010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86011       };
86012     } catch (...) {
86013       {
86014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86015       };
86016     }
86017   }
86018
86019   jresult = (void *)result;
86020   return jresult;
86021 }
86022
86023
86024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86025   void * jresult ;
86026   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86027   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86028
86029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86030   {
86031     try {
86032       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86033     } catch (std::out_of_range& e) {
86034       {
86035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86036       };
86037     } catch (std::exception& e) {
86038       {
86039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86040       };
86041     } catch (Dali::DaliException e) {
86042       {
86043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86044       };
86045     } catch (...) {
86046       {
86047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86048       };
86049     }
86050   }
86051
86052   jresult = (void *)result;
86053   return jresult;
86054 }
86055
86056
86057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86058   void * jresult ;
86059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86060   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86061
86062   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86063   {
86064     try {
86065       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86066     } catch (std::out_of_range& e) {
86067       {
86068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86069       };
86070     } catch (std::exception& e) {
86071       {
86072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86073       };
86074     } catch (Dali::DaliException e) {
86075       {
86076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86077       };
86078     } catch (...) {
86079       {
86080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86081       };
86082     }
86083   }
86084
86085   jresult = (void *)result;
86086   return jresult;
86087 }
86088
86089
86090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86091   void * jresult ;
86092   Dali::Toolkit::StyleManager *result = 0 ;
86093
86094   {
86095     try {
86096       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86097     } catch (std::out_of_range& e) {
86098       {
86099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86100       };
86101     } catch (std::exception& e) {
86102       {
86103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86104       };
86105     } catch (Dali::DaliException e) {
86106       {
86107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86108       };
86109     } catch (...) {
86110       {
86111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86112       };
86113     }
86114   }
86115
86116   jresult = (void *)result;
86117   return jresult;
86118 }
86119
86120
86121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86122   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86123
86124   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86125   {
86126     try {
86127       delete arg1;
86128     } catch (std::out_of_range& e) {
86129       {
86130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86131       };
86132     } catch (std::exception& e) {
86133       {
86134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86135       };
86136     } catch (Dali::DaliException e) {
86137       {
86138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86139       };
86140     } catch (...) {
86141       {
86142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86143       };
86144     }
86145   }
86146
86147 }
86148
86149
86150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86151   void * jresult ;
86152   Dali::Toolkit::StyleManager result;
86153
86154   {
86155     try {
86156       result = Dali::Toolkit::StyleManager::Get();
86157     } catch (std::out_of_range& e) {
86158       {
86159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86160       };
86161     } catch (std::exception& e) {
86162       {
86163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86164       };
86165     } catch (Dali::DaliException e) {
86166       {
86167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86168       };
86169     } catch (...) {
86170       {
86171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86172       };
86173     }
86174   }
86175
86176   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86177   return jresult;
86178 }
86179
86180
86181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86182   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86183   std::string *arg2 = 0 ;
86184
86185   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86186   if (!jarg2) {
86187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86188     return ;
86189   }
86190   std::string arg2_str(jarg2);
86191   arg2 = &arg2_str;
86192   {
86193     try {
86194       (arg1)->ApplyTheme((std::string const &)*arg2);
86195     } catch (std::out_of_range& e) {
86196       {
86197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86198       };
86199     } catch (std::exception& e) {
86200       {
86201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86202       };
86203     } catch (Dali::DaliException e) {
86204       {
86205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86206       };
86207     } catch (...) {
86208       {
86209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86210       };
86211     }
86212   }
86213
86214
86215   //argout typemap for const std::string&
86216
86217 }
86218
86219
86220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86221   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86222
86223   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86224   {
86225     try {
86226       (arg1)->ApplyDefaultTheme();
86227     } catch (std::out_of_range& e) {
86228       {
86229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86230       };
86231     } catch (std::exception& e) {
86232       {
86233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86234       };
86235     } catch (Dali::DaliException e) {
86236       {
86237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86238       };
86239     } catch (...) {
86240       {
86241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86242       };
86243     }
86244   }
86245
86246 }
86247
86248
86249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86250   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86251   std::string *arg2 = 0 ;
86252   Dali::Property::Value *arg3 = 0 ;
86253
86254   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86255   if (!jarg2) {
86256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86257     return ;
86258   }
86259   std::string arg2_str(jarg2);
86260   arg2 = &arg2_str;
86261   arg3 = (Dali::Property::Value *)jarg3;
86262   if (!arg3) {
86263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86264     return ;
86265   }
86266   {
86267     try {
86268       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86269     } catch (std::out_of_range& e) {
86270       {
86271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86272       };
86273     } catch (std::exception& e) {
86274       {
86275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86276       };
86277     } catch (Dali::DaliException e) {
86278       {
86279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86280       };
86281     } catch (...) {
86282       {
86283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86284       };
86285     }
86286   }
86287
86288
86289   //argout typemap for const std::string&
86290
86291 }
86292
86293
86294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86295   unsigned int jresult ;
86296   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86297   std::string *arg2 = 0 ;
86298   Dali::Property::Value *arg3 = 0 ;
86299   bool result;
86300
86301   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86302   if (!jarg2) {
86303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86304     return 0;
86305   }
86306   std::string arg2_str(jarg2);
86307   arg2 = &arg2_str;
86308   arg3 = (Dali::Property::Value *)jarg3;
86309   if (!arg3) {
86310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86311     return 0;
86312   }
86313   {
86314     try {
86315       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86316     } catch (std::out_of_range& e) {
86317       {
86318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86319       };
86320     } catch (std::exception& e) {
86321       {
86322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86323       };
86324     } catch (Dali::DaliException e) {
86325       {
86326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86327       };
86328     } catch (...) {
86329       {
86330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86331       };
86332     }
86333   }
86334
86335   jresult = result;
86336
86337   //argout typemap for const std::string&
86338
86339   return jresult;
86340 }
86341
86342
86343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86344   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86345   Dali::Toolkit::Control arg2 ;
86346   std::string *arg3 = 0 ;
86347   std::string *arg4 = 0 ;
86348   Dali::Toolkit::Control *argp2 ;
86349
86350   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86351   argp2 = (Dali::Toolkit::Control *)jarg2;
86352   if (!argp2) {
86353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86354     return ;
86355   }
86356   arg2 = *argp2;
86357   if (!jarg3) {
86358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86359     return ;
86360   }
86361   std::string arg3_str(jarg3);
86362   arg3 = &arg3_str;
86363   if (!jarg4) {
86364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86365     return ;
86366   }
86367   std::string arg4_str(jarg4);
86368   arg4 = &arg4_str;
86369   {
86370     try {
86371       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86372     } catch (std::out_of_range& e) {
86373       {
86374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86375       };
86376     } catch (std::exception& e) {
86377       {
86378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86379       };
86380     } catch (Dali::DaliException e) {
86381       {
86382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86383       };
86384     } catch (...) {
86385       {
86386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86387       };
86388     }
86389   }
86390
86391
86392   //argout typemap for const std::string&
86393
86394
86395   //argout typemap for const std::string&
86396
86397 }
86398
86399
86400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86401   void * jresult ;
86402   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86403   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86404
86405   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86406   {
86407     try {
86408       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86409     } catch (std::out_of_range& e) {
86410       {
86411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86412       };
86413     } catch (std::exception& e) {
86414       {
86415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86416       };
86417     } catch (Dali::DaliException e) {
86418       {
86419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86420       };
86421     } catch (...) {
86422       {
86423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86424       };
86425     }
86426   }
86427
86428   jresult = (void *)result;
86429   return jresult;
86430 }
86431
86432
86433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86434   int jresult ;
86435   int result;
86436
86437   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86438   jresult = (int)result;
86439   return jresult;
86440 }
86441
86442
86443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86444   int jresult ;
86445   int result;
86446
86447   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86448   jresult = (int)result;
86449   return jresult;
86450 }
86451
86452
86453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86454   int jresult ;
86455   int result;
86456
86457   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86458   jresult = (int)result;
86459   return jresult;
86460 }
86461
86462
86463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86464   int jresult ;
86465   int result;
86466
86467   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86468   jresult = (int)result;
86469   return jresult;
86470 }
86471
86472
86473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86474   int jresult ;
86475   int result;
86476
86477   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86478   jresult = (int)result;
86479   return jresult;
86480 }
86481
86482
86483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86484   int jresult ;
86485   int result;
86486
86487   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86488   jresult = (int)result;
86489   return jresult;
86490 }
86491
86492
86493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86494   int jresult ;
86495   int result;
86496
86497   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86498   jresult = (int)result;
86499   return jresult;
86500 }
86501
86502
86503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86504   int jresult ;
86505   int result;
86506
86507   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86508   jresult = (int)result;
86509   return jresult;
86510 }
86511
86512
86513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86514   int jresult ;
86515   int result;
86516
86517   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86518   jresult = (int)result;
86519   return jresult;
86520 }
86521
86522
86523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86524   int jresult ;
86525   int result;
86526
86527   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86528   jresult = (int)result;
86529   return jresult;
86530 }
86531
86532
86533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86534   int jresult ;
86535   int result;
86536
86537   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86538   jresult = (int)result;
86539   return jresult;
86540 }
86541
86542
86543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86544   int jresult ;
86545   int result;
86546
86547   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86548   jresult = (int)result;
86549   return jresult;
86550 }
86551
86552
86553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86554   int jresult ;
86555   int result;
86556
86557   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86558   jresult = (int)result;
86559   return jresult;
86560 }
86561
86562
86563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86564   int jresult ;
86565   int result;
86566
86567   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86568   jresult = (int)result;
86569   return jresult;
86570 }
86571
86572
86573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86574   int jresult ;
86575   int result;
86576
86577   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86578   jresult = (int)result;
86579   return jresult;
86580 }
86581
86582
86583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86584   void * jresult ;
86585   Dali::Toolkit::Slider::Property *result = 0 ;
86586
86587   {
86588     try {
86589       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86590     } catch (std::out_of_range& e) {
86591       {
86592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86593       };
86594     } catch (std::exception& e) {
86595       {
86596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86597       };
86598     } catch (Dali::DaliException e) {
86599       {
86600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86601       };
86602     } catch (...) {
86603       {
86604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86605       };
86606     }
86607   }
86608
86609   jresult = (void *)result;
86610   return jresult;
86611 }
86612
86613
86614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86615   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86616
86617   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86618   {
86619     try {
86620       delete arg1;
86621     } catch (std::out_of_range& e) {
86622       {
86623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86624       };
86625     } catch (std::exception& e) {
86626       {
86627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86628       };
86629     } catch (Dali::DaliException e) {
86630       {
86631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86632       };
86633     } catch (...) {
86634       {
86635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86636       };
86637     }
86638   }
86639
86640 }
86641
86642
86643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86644   void * jresult ;
86645   Dali::Toolkit::Slider result;
86646
86647   {
86648     try {
86649       result = Dali::Toolkit::Slider::New();
86650     } catch (std::out_of_range& e) {
86651       {
86652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86653       };
86654     } catch (std::exception& e) {
86655       {
86656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86657       };
86658     } catch (Dali::DaliException e) {
86659       {
86660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86661       };
86662     } catch (...) {
86663       {
86664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86665       };
86666     }
86667   }
86668
86669   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86670   return jresult;
86671 }
86672
86673
86674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86675   void * jresult ;
86676   Dali::Toolkit::Slider *result = 0 ;
86677
86678   {
86679     try {
86680       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86681     } catch (std::out_of_range& e) {
86682       {
86683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86684       };
86685     } catch (std::exception& e) {
86686       {
86687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86688       };
86689     } catch (Dali::DaliException e) {
86690       {
86691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86692       };
86693     } catch (...) {
86694       {
86695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86696       };
86697     }
86698   }
86699
86700   jresult = (void *)result;
86701   return jresult;
86702 }
86703
86704
86705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86706   void * jresult ;
86707   Dali::Toolkit::Slider *arg1 = 0 ;
86708   Dali::Toolkit::Slider *result = 0 ;
86709
86710   arg1 = (Dali::Toolkit::Slider *)jarg1;
86711   if (!arg1) {
86712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86713     return 0;
86714   }
86715   {
86716     try {
86717       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86718     } catch (std::out_of_range& e) {
86719       {
86720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86721       };
86722     } catch (std::exception& e) {
86723       {
86724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86725       };
86726     } catch (Dali::DaliException e) {
86727       {
86728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86729       };
86730     } catch (...) {
86731       {
86732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86733       };
86734     }
86735   }
86736
86737   jresult = (void *)result;
86738   return jresult;
86739 }
86740
86741
86742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86743   void * jresult ;
86744   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86745   Dali::Toolkit::Slider *arg2 = 0 ;
86746   Dali::Toolkit::Slider *result = 0 ;
86747
86748   arg1 = (Dali::Toolkit::Slider *)jarg1;
86749   arg2 = (Dali::Toolkit::Slider *)jarg2;
86750   if (!arg2) {
86751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86752     return 0;
86753   }
86754   {
86755     try {
86756       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86757     } catch (std::out_of_range& e) {
86758       {
86759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86760       };
86761     } catch (std::exception& e) {
86762       {
86763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86764       };
86765     } catch (Dali::DaliException e) {
86766       {
86767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86768       };
86769     } catch (...) {
86770       {
86771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86772       };
86773     }
86774   }
86775
86776   jresult = (void *)result;
86777   return jresult;
86778 }
86779
86780
86781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86782   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86783
86784   arg1 = (Dali::Toolkit::Slider *)jarg1;
86785   {
86786     try {
86787       delete arg1;
86788     } catch (std::out_of_range& e) {
86789       {
86790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86791       };
86792     } catch (std::exception& e) {
86793       {
86794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86795       };
86796     } catch (Dali::DaliException e) {
86797       {
86798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86799       };
86800     } catch (...) {
86801       {
86802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86803       };
86804     }
86805   }
86806
86807 }
86808
86809
86810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86811   void * jresult ;
86812   Dali::BaseHandle arg1 ;
86813   Dali::BaseHandle *argp1 ;
86814   Dali::Toolkit::Slider result;
86815
86816   argp1 = (Dali::BaseHandle *)jarg1;
86817   if (!argp1) {
86818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86819     return 0;
86820   }
86821   arg1 = *argp1;
86822   {
86823     try {
86824       result = Dali::Toolkit::Slider::DownCast(arg1);
86825     } catch (std::out_of_range& e) {
86826       {
86827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86828       };
86829     } catch (std::exception& e) {
86830       {
86831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86832       };
86833     } catch (Dali::DaliException e) {
86834       {
86835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86836       };
86837     } catch (...) {
86838       {
86839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86840       };
86841     }
86842   }
86843
86844   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86845   return jresult;
86846 }
86847
86848
86849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
86850   void * jresult ;
86851   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86852   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86853
86854   arg1 = (Dali::Toolkit::Slider *)jarg1;
86855   {
86856     try {
86857       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
86858     } catch (std::out_of_range& e) {
86859       {
86860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86861       };
86862     } catch (std::exception& e) {
86863       {
86864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86865       };
86866     } catch (Dali::DaliException e) {
86867       {
86868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86869       };
86870     } catch (...) {
86871       {
86872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86873       };
86874     }
86875   }
86876
86877   jresult = (void *)result;
86878   return jresult;
86879 }
86880
86881
86882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
86883   void * jresult ;
86884   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86885   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86886
86887   arg1 = (Dali::Toolkit::Slider *)jarg1;
86888   {
86889     try {
86890       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
86891     } catch (std::out_of_range& e) {
86892       {
86893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86894       };
86895     } catch (std::exception& e) {
86896       {
86897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86898       };
86899     } catch (Dali::DaliException e) {
86900       {
86901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86902       };
86903     } catch (...) {
86904       {
86905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86906       };
86907     }
86908   }
86909
86910   jresult = (void *)result;
86911   return jresult;
86912 }
86913
86914
86915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86916   void * jresult ;
86917   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86918   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86919
86920   arg1 = (Dali::Toolkit::Slider *)jarg1;
86921   {
86922     try {
86923       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86924     } catch (std::out_of_range& e) {
86925       {
86926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86927       };
86928     } catch (std::exception& e) {
86929       {
86930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86931       };
86932     } catch (Dali::DaliException e) {
86933       {
86934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86935       };
86936     } catch (...) {
86937       {
86938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86939       };
86940     }
86941   }
86942
86943   jresult = (void *)result;
86944   return jresult;
86945 }
86946
86947
86948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86949   int jresult ;
86950   int result;
86951
86952   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86953   jresult = (int)result;
86954   return jresult;
86955 }
86956
86957
86958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86959   int jresult ;
86960   int result;
86961
86962   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86963   jresult = (int)result;
86964   return jresult;
86965 }
86966
86967
86968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86969   int jresult ;
86970   int result;
86971
86972   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86973   jresult = (int)result;
86974   return jresult;
86975 }
86976
86977
86978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86979   int jresult ;
86980   int result;
86981
86982   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86983   jresult = (int)result;
86984   return jresult;
86985 }
86986
86987
86988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86989   int result;
86990
86991   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86992
86993   return result;
86994 }
86995
86996
86997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86998   void * jresult ;
86999   Dali::Toolkit::VideoView::Property *result = 0 ;
87000
87001   {
87002     try {
87003       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87004     } catch (std::out_of_range& e) {
87005       {
87006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87007       };
87008     } catch (std::exception& e) {
87009       {
87010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87011       };
87012     } catch (Dali::DaliException e) {
87013       {
87014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87015       };
87016     } catch (...) {
87017       {
87018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87019       };
87020     }
87021   }
87022
87023   jresult = (void *)result;
87024   return jresult;
87025 }
87026
87027
87028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87029   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87030
87031   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87032   {
87033     try {
87034       delete arg1;
87035     } catch (std::out_of_range& e) {
87036       {
87037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87038       };
87039     } catch (std::exception& e) {
87040       {
87041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87042       };
87043     } catch (Dali::DaliException e) {
87044       {
87045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87046       };
87047     } catch (...) {
87048       {
87049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87050       };
87051     }
87052   }
87053
87054 }
87055
87056
87057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87058   void * jresult ;
87059   Dali::Toolkit::VideoView result;
87060
87061   {
87062     try {
87063       result = Dali::Toolkit::VideoView::New();
87064     } catch (std::out_of_range& e) {
87065       {
87066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87067       };
87068     } catch (std::exception& e) {
87069       {
87070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87071       };
87072     } catch (Dali::DaliException e) {
87073       {
87074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87075       };
87076     } catch (...) {
87077       {
87078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87079       };
87080     }
87081   }
87082
87083   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87084   return jresult;
87085 }
87086
87087
87088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87089   void * jresult ;
87090   std::string *arg1 = 0 ;
87091   Dali::Toolkit::VideoView result;
87092
87093   if (!jarg1) {
87094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87095     return 0;
87096   }
87097   std::string arg1_str(jarg1);
87098   arg1 = &arg1_str;
87099   {
87100     try {
87101       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87102     } catch (std::out_of_range& e) {
87103       {
87104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87105       };
87106     } catch (std::exception& e) {
87107       {
87108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87109       };
87110     } catch (Dali::DaliException e) {
87111       {
87112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87113       };
87114     } catch (...) {
87115       {
87116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87117       };
87118     }
87119   }
87120
87121   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87122
87123   //argout typemap for const std::string&
87124
87125   return jresult;
87126 }
87127
87128
87129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87130   void * jresult ;
87131   Dali::Toolkit::VideoView *result = 0 ;
87132
87133   {
87134     try {
87135       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87136     } catch (std::out_of_range& e) {
87137       {
87138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87139       };
87140     } catch (std::exception& e) {
87141       {
87142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87143       };
87144     } catch (Dali::DaliException e) {
87145       {
87146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87147       };
87148     } catch (...) {
87149       {
87150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87151       };
87152     }
87153   }
87154
87155   jresult = (void *)result;
87156   return jresult;
87157 }
87158
87159
87160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87161   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87162
87163   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87164   {
87165     try {
87166       delete arg1;
87167     } catch (std::out_of_range& e) {
87168       {
87169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87170       };
87171     } catch (std::exception& e) {
87172       {
87173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87174       };
87175     } catch (Dali::DaliException e) {
87176       {
87177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87178       };
87179     } catch (...) {
87180       {
87181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87182       };
87183     }
87184   }
87185
87186 }
87187
87188
87189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87190   void * jresult ;
87191   Dali::Toolkit::VideoView *arg1 = 0 ;
87192   Dali::Toolkit::VideoView *result = 0 ;
87193
87194   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87195   if (!arg1) {
87196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87197     return 0;
87198   }
87199   {
87200     try {
87201       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87202     } catch (std::out_of_range& e) {
87203       {
87204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87205       };
87206     } catch (std::exception& e) {
87207       {
87208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87209       };
87210     } catch (Dali::DaliException e) {
87211       {
87212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87213       };
87214     } catch (...) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87217       };
87218     }
87219   }
87220
87221   jresult = (void *)result;
87222   return jresult;
87223 }
87224
87225
87226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87227   void * jresult ;
87228   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87229   Dali::Toolkit::VideoView *arg2 = 0 ;
87230   Dali::Toolkit::VideoView *result = 0 ;
87231
87232   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87233   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87234   if (!arg2) {
87235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87236     return 0;
87237   }
87238   {
87239     try {
87240       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87241     } catch (std::out_of_range& e) {
87242       {
87243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87244       };
87245     } catch (std::exception& e) {
87246       {
87247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87248       };
87249     } catch (Dali::DaliException e) {
87250       {
87251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87252       };
87253     } catch (...) {
87254       {
87255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87256       };
87257     }
87258   }
87259
87260   jresult = (void *)result;
87261   return jresult;
87262 }
87263
87264
87265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87266   void * jresult ;
87267   Dali::BaseHandle arg1 ;
87268   Dali::BaseHandle *argp1 ;
87269   Dali::Toolkit::VideoView result;
87270
87271   argp1 = (Dali::BaseHandle *)jarg1;
87272   if (!argp1) {
87273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87274     return 0;
87275   }
87276   arg1 = *argp1;
87277   {
87278     try {
87279       result = Dali::Toolkit::VideoView::DownCast(arg1);
87280     } catch (std::out_of_range& e) {
87281       {
87282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87283       };
87284     } catch (std::exception& e) {
87285       {
87286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87287       };
87288     } catch (Dali::DaliException e) {
87289       {
87290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87291       };
87292     } catch (...) {
87293       {
87294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87295       };
87296     }
87297   }
87298
87299   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87300   return jresult;
87301 }
87302
87303
87304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87305   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87306
87307   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87308   {
87309     try {
87310       (arg1)->Play();
87311     } catch (std::out_of_range& e) {
87312       {
87313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87314       };
87315     } catch (std::exception& e) {
87316       {
87317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87318       };
87319     } catch (Dali::DaliException e) {
87320       {
87321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87322       };
87323     } catch (...) {
87324       {
87325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87326       };
87327     }
87328   }
87329
87330 }
87331
87332
87333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87334   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87335
87336   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87337   {
87338     try {
87339       (arg1)->Pause();
87340     } catch (std::out_of_range& e) {
87341       {
87342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87343       };
87344     } catch (std::exception& e) {
87345       {
87346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87347       };
87348     } catch (Dali::DaliException e) {
87349       {
87350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87351       };
87352     } catch (...) {
87353       {
87354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87355       };
87356     }
87357   }
87358
87359 }
87360
87361
87362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87363   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87364
87365   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87366   {
87367     try {
87368       (arg1)->Stop();
87369     } catch (std::out_of_range& e) {
87370       {
87371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87372       };
87373     } catch (std::exception& e) {
87374       {
87375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87376       };
87377     } catch (Dali::DaliException e) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87380       };
87381     } catch (...) {
87382       {
87383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87384       };
87385     }
87386   }
87387
87388 }
87389
87390
87391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87392   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87393   int arg2 ;
87394
87395   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87396   arg2 = (int)jarg2;
87397   {
87398     try {
87399       (arg1)->Forward(arg2);
87400     } catch (std::out_of_range& e) {
87401       {
87402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87403       };
87404     } catch (std::exception& e) {
87405       {
87406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87407       };
87408     } catch (Dali::DaliException e) {
87409       {
87410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87411       };
87412     } catch (...) {
87413       {
87414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87415       };
87416     }
87417   }
87418
87419 }
87420
87421
87422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87423   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87424   int arg2 ;
87425
87426   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87427   arg2 = (int)jarg2;
87428   {
87429     try {
87430       (arg1)->Backward(arg2);
87431     } catch (std::out_of_range& e) {
87432       {
87433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87434       };
87435     } catch (std::exception& e) {
87436       {
87437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87438       };
87439     } catch (Dali::DaliException e) {
87440       {
87441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87442       };
87443     } catch (...) {
87444       {
87445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87446       };
87447     }
87448   }
87449
87450 }
87451
87452
87453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87454   void * jresult ;
87455   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87456   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87457
87458   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87459   {
87460     try {
87461       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87462     } catch (std::out_of_range& e) {
87463       {
87464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87465       };
87466     } catch (std::exception& e) {
87467       {
87468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87469       };
87470     } catch (Dali::DaliException e) {
87471       {
87472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87473       };
87474     } catch (...) {
87475       {
87476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87477       };
87478     }
87479   }
87480
87481   jresult = (void *)result;
87482   return jresult;
87483 }
87484
87485
87486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87487   int jresult ;
87488   int result;
87489
87490   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87491   jresult = (int)result;
87492   return jresult;
87493 }
87494
87495
87496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87497   int jresult ;
87498   int result;
87499
87500   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87501   jresult = (int)result;
87502   return jresult;
87503 }
87504
87505
87506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87507   int jresult ;
87508   int result;
87509
87510   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87511   jresult = (int)result;
87512   return jresult;
87513 }
87514
87515
87516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87517   int jresult ;
87518   int result;
87519
87520   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87521   jresult = (int)result;
87522   return jresult;
87523 }
87524
87525
87526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87527   int jresult ;
87528   int result;
87529
87530   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87531   jresult = (int)result;
87532   return jresult;
87533 }
87534
87535
87536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87537   int jresult ;
87538   int result;
87539
87540   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87541   jresult = (int)result;
87542   return jresult;
87543 }
87544
87545
87546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87547   int jresult ;
87548   int result;
87549
87550   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87551   jresult = (int)result;
87552   return jresult;
87553 }
87554
87555
87556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87557   int jresult ;
87558   int result;
87559
87560   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87561   jresult = (int)result;
87562   return jresult;
87563 }
87564
87565
87566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87567   int jresult ;
87568   int result;
87569
87570   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87571   jresult = (int)result;
87572   return jresult;
87573 }
87574
87575
87576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87577   int jresult ;
87578   int result;
87579
87580   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87581   jresult = (int)result;
87582   return jresult;
87583 }
87584
87585
87586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87587   int jresult ;
87588   int result;
87589
87590   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87591   jresult = (int)result;
87592   return jresult;
87593 }
87594
87595
87596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87597   int jresult ;
87598   int result;
87599
87600   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87601   jresult = (int)result;
87602   return jresult;
87603 }
87604
87605
87606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87607   int jresult ;
87608   int result;
87609
87610   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87611   jresult = (int)result;
87612   return jresult;
87613 }
87614
87615
87616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87617   int jresult ;
87618   int result;
87619
87620   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87621   jresult = (int)result;
87622   return jresult;
87623 }
87624
87625
87626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87627   int jresult ;
87628   int result;
87629
87630   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87631   jresult = (int)result;
87632   return jresult;
87633 }
87634
87635
87636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87637   int jresult ;
87638   int result;
87639
87640   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87641   jresult = (int)result;
87642   return jresult;
87643 }
87644
87645
87646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87647   int jresult ;
87648   int result;
87649
87650   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87651   jresult = (int)result;
87652   return jresult;
87653 }
87654
87655
87656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87657   int jresult ;
87658   int result;
87659
87660   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87661   jresult = (int)result;
87662   return jresult;
87663 }
87664
87665
87666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87667   int jresult ;
87668   int result;
87669
87670   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87671   jresult = (int)result;
87672   return jresult;
87673 }
87674
87675
87676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87677   int jresult ;
87678   int result;
87679
87680   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87681   jresult = (int)result;
87682   return jresult;
87683 }
87684
87685
87686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87687   int jresult ;
87688   int result;
87689
87690   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87691   jresult = (int)result;
87692   return jresult;
87693 }
87694
87695
87696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87697   void * jresult ;
87698   Dali::Toolkit::Popup::Property *result = 0 ;
87699
87700   {
87701     try {
87702       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87703     } catch (std::out_of_range& e) {
87704       {
87705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87706       };
87707     } catch (std::exception& e) {
87708       {
87709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87710       };
87711     } catch (Dali::DaliException e) {
87712       {
87713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87714       };
87715     } catch (...) {
87716       {
87717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87718       };
87719     }
87720   }
87721
87722   jresult = (void *)result;
87723   return jresult;
87724 }
87725
87726
87727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87728   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87729
87730   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87731   {
87732     try {
87733       delete arg1;
87734     } catch (std::out_of_range& e) {
87735       {
87736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87737       };
87738     } catch (std::exception& e) {
87739       {
87740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87741       };
87742     } catch (Dali::DaliException e) {
87743       {
87744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87745       };
87746     } catch (...) {
87747       {
87748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87749       };
87750     }
87751   }
87752
87753 }
87754
87755
87756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87757   void * jresult ;
87758   Dali::Toolkit::Popup *result = 0 ;
87759
87760   {
87761     try {
87762       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87763     } catch (std::out_of_range& e) {
87764       {
87765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87766       };
87767     } catch (std::exception& e) {
87768       {
87769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87770       };
87771     } catch (Dali::DaliException e) {
87772       {
87773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87774       };
87775     } catch (...) {
87776       {
87777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87778       };
87779     }
87780   }
87781
87782   jresult = (void *)result;
87783   return jresult;
87784 }
87785
87786
87787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87788   void * jresult ;
87789   Dali::Toolkit::Popup result;
87790
87791   {
87792     try {
87793       result = Dali::Toolkit::Popup::New();
87794     } catch (std::out_of_range& e) {
87795       {
87796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87797       };
87798     } catch (std::exception& e) {
87799       {
87800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87801       };
87802     } catch (Dali::DaliException e) {
87803       {
87804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87805       };
87806     } catch (...) {
87807       {
87808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87809       };
87810     }
87811   }
87812
87813   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87814   return jresult;
87815 }
87816
87817
87818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87819   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87820
87821   arg1 = (Dali::Toolkit::Popup *)jarg1;
87822   {
87823     try {
87824       delete arg1;
87825     } catch (std::out_of_range& e) {
87826       {
87827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87828       };
87829     } catch (std::exception& e) {
87830       {
87831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87832       };
87833     } catch (Dali::DaliException e) {
87834       {
87835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87836       };
87837     } catch (...) {
87838       {
87839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87840       };
87841     }
87842   }
87843
87844 }
87845
87846
87847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87848   void * jresult ;
87849   Dali::Toolkit::Popup *arg1 = 0 ;
87850   Dali::Toolkit::Popup *result = 0 ;
87851
87852   arg1 = (Dali::Toolkit::Popup *)jarg1;
87853   if (!arg1) {
87854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87855     return 0;
87856   }
87857   {
87858     try {
87859       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87860     } catch (std::out_of_range& e) {
87861       {
87862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87863       };
87864     } catch (std::exception& e) {
87865       {
87866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87867       };
87868     } catch (Dali::DaliException e) {
87869       {
87870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87871       };
87872     } catch (...) {
87873       {
87874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87875       };
87876     }
87877   }
87878
87879   jresult = (void *)result;
87880   return jresult;
87881 }
87882
87883
87884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87885   void * jresult ;
87886   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87887   Dali::Toolkit::Popup *arg2 = 0 ;
87888   Dali::Toolkit::Popup *result = 0 ;
87889
87890   arg1 = (Dali::Toolkit::Popup *)jarg1;
87891   arg2 = (Dali::Toolkit::Popup *)jarg2;
87892   if (!arg2) {
87893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87894     return 0;
87895   }
87896   {
87897     try {
87898       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87899     } catch (std::out_of_range& e) {
87900       {
87901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87902       };
87903     } catch (std::exception& e) {
87904       {
87905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87906       };
87907     } catch (Dali::DaliException e) {
87908       {
87909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87910       };
87911     } catch (...) {
87912       {
87913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87914       };
87915     }
87916   }
87917
87918   jresult = (void *)result;
87919   return jresult;
87920 }
87921
87922
87923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87924   void * jresult ;
87925   Dali::BaseHandle arg1 ;
87926   Dali::BaseHandle *argp1 ;
87927   Dali::Toolkit::Popup result;
87928
87929   argp1 = (Dali::BaseHandle *)jarg1;
87930   if (!argp1) {
87931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87932     return 0;
87933   }
87934   arg1 = *argp1;
87935   {
87936     try {
87937       result = Dali::Toolkit::Popup::DownCast(arg1);
87938     } catch (std::out_of_range& e) {
87939       {
87940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87941       };
87942     } catch (std::exception& e) {
87943       {
87944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87945       };
87946     } catch (Dali::DaliException e) {
87947       {
87948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87949       };
87950     } catch (...) {
87951       {
87952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87953       };
87954     }
87955   }
87956
87957   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87958   return jresult;
87959 }
87960
87961
87962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87963   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87964   Dali::Actor arg2 ;
87965   Dali::Actor *argp2 ;
87966
87967   arg1 = (Dali::Toolkit::Popup *)jarg1;
87968   argp2 = (Dali::Actor *)jarg2;
87969   if (!argp2) {
87970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87971     return ;
87972   }
87973   arg2 = *argp2;
87974   {
87975     try {
87976       (arg1)->SetTitle(arg2);
87977     } catch (std::out_of_range& e) {
87978       {
87979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87980       };
87981     } catch (std::exception& e) {
87982       {
87983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87984       };
87985     } catch (Dali::DaliException e) {
87986       {
87987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87988       };
87989     } catch (...) {
87990       {
87991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87992       };
87993     }
87994   }
87995
87996 }
87997
87998
87999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88000   void * jresult ;
88001   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88002   Dali::Actor result;
88003
88004   arg1 = (Dali::Toolkit::Popup *)jarg1;
88005   {
88006     try {
88007       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88008     } catch (std::out_of_range& e) {
88009       {
88010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88011       };
88012     } catch (std::exception& e) {
88013       {
88014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88015       };
88016     } catch (Dali::DaliException e) {
88017       {
88018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88019       };
88020     } catch (...) {
88021       {
88022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88023       };
88024     }
88025   }
88026
88027   jresult = new Dali::Actor((const Dali::Actor &)result);
88028   return jresult;
88029 }
88030
88031
88032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88033   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88034   Dali::Actor arg2 ;
88035   Dali::Actor *argp2 ;
88036
88037   arg1 = (Dali::Toolkit::Popup *)jarg1;
88038   argp2 = (Dali::Actor *)jarg2;
88039   if (!argp2) {
88040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88041     return ;
88042   }
88043   arg2 = *argp2;
88044   {
88045     try {
88046       (arg1)->SetContent(arg2);
88047     } catch (std::out_of_range& e) {
88048       {
88049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88050       };
88051     } catch (std::exception& e) {
88052       {
88053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88054       };
88055     } catch (Dali::DaliException e) {
88056       {
88057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88058       };
88059     } catch (...) {
88060       {
88061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88062       };
88063     }
88064   }
88065
88066 }
88067
88068
88069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88070   void * jresult ;
88071   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88072   Dali::Actor result;
88073
88074   arg1 = (Dali::Toolkit::Popup *)jarg1;
88075   {
88076     try {
88077       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88078     } catch (std::out_of_range& e) {
88079       {
88080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88081       };
88082     } catch (std::exception& e) {
88083       {
88084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88085       };
88086     } catch (Dali::DaliException e) {
88087       {
88088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88089       };
88090     } catch (...) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88093       };
88094     }
88095   }
88096
88097   jresult = new Dali::Actor((const Dali::Actor &)result);
88098   return jresult;
88099 }
88100
88101
88102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88103   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88104   Dali::Actor arg2 ;
88105   Dali::Actor *argp2 ;
88106
88107   arg1 = (Dali::Toolkit::Popup *)jarg1;
88108   argp2 = (Dali::Actor *)jarg2;
88109   if (!argp2) {
88110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88111     return ;
88112   }
88113   arg2 = *argp2;
88114   {
88115     try {
88116       (arg1)->SetFooter(arg2);
88117     } catch (std::out_of_range& e) {
88118       {
88119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88120       };
88121     } catch (std::exception& e) {
88122       {
88123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88124       };
88125     } catch (Dali::DaliException e) {
88126       {
88127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88128       };
88129     } catch (...) {
88130       {
88131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88132       };
88133     }
88134   }
88135
88136 }
88137
88138
88139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88140   void * jresult ;
88141   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88142   Dali::Actor result;
88143
88144   arg1 = (Dali::Toolkit::Popup *)jarg1;
88145   {
88146     try {
88147       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88148     } catch (std::out_of_range& e) {
88149       {
88150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88151       };
88152     } catch (std::exception& e) {
88153       {
88154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88155       };
88156     } catch (Dali::DaliException e) {
88157       {
88158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88159       };
88160     } catch (...) {
88161       {
88162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88163       };
88164     }
88165   }
88166
88167   jresult = new Dali::Actor((const Dali::Actor &)result);
88168   return jresult;
88169 }
88170
88171
88172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88173   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88174   Dali::Toolkit::Popup::DisplayState arg2 ;
88175
88176   arg1 = (Dali::Toolkit::Popup *)jarg1;
88177   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88178   {
88179     try {
88180       (arg1)->SetDisplayState(arg2);
88181     } catch (std::out_of_range& e) {
88182       {
88183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88184       };
88185     } catch (std::exception& e) {
88186       {
88187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88188       };
88189     } catch (Dali::DaliException e) {
88190       {
88191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88192       };
88193     } catch (...) {
88194       {
88195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88196       };
88197     }
88198   }
88199
88200 }
88201
88202
88203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88204   int jresult ;
88205   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88206   Dali::Toolkit::Popup::DisplayState result;
88207
88208   arg1 = (Dali::Toolkit::Popup *)jarg1;
88209   {
88210     try {
88211       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88212     } catch (std::out_of_range& e) {
88213       {
88214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88215       };
88216     } catch (std::exception& e) {
88217       {
88218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88219       };
88220     } catch (Dali::DaliException e) {
88221       {
88222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88223       };
88224     } catch (...) {
88225       {
88226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88227       };
88228     }
88229   }
88230
88231   jresult = (int)result;
88232   return jresult;
88233 }
88234
88235
88236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88237   void * jresult ;
88238   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88239   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88240
88241   arg1 = (Dali::Toolkit::Popup *)jarg1;
88242   {
88243     try {
88244       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88245     } catch (std::out_of_range& e) {
88246       {
88247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88248       };
88249     } catch (std::exception& e) {
88250       {
88251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88252       };
88253     } catch (Dali::DaliException e) {
88254       {
88255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88256       };
88257     } catch (...) {
88258       {
88259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88260       };
88261     }
88262   }
88263
88264   jresult = (void *)result;
88265   return jresult;
88266 }
88267
88268
88269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88270   void * jresult ;
88271   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88272   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88273
88274   arg1 = (Dali::Toolkit::Popup *)jarg1;
88275   {
88276     try {
88277       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88278     } catch (std::out_of_range& e) {
88279       {
88280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88281       };
88282     } catch (std::exception& e) {
88283       {
88284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88285       };
88286     } catch (Dali::DaliException e) {
88287       {
88288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88289       };
88290     } catch (...) {
88291       {
88292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88293       };
88294     }
88295   }
88296
88297   jresult = (void *)result;
88298   return jresult;
88299 }
88300
88301
88302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88303   void * jresult ;
88304   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88305   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88306
88307   arg1 = (Dali::Toolkit::Popup *)jarg1;
88308   {
88309     try {
88310       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88311     } catch (std::out_of_range& e) {
88312       {
88313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88314       };
88315     } catch (std::exception& e) {
88316       {
88317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88318       };
88319     } catch (Dali::DaliException e) {
88320       {
88321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88322       };
88323     } catch (...) {
88324       {
88325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88326       };
88327     }
88328   }
88329
88330   jresult = (void *)result;
88331   return jresult;
88332 }
88333
88334
88335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88336   void * jresult ;
88337   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88338   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88339
88340   arg1 = (Dali::Toolkit::Popup *)jarg1;
88341   {
88342     try {
88343       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88344     } catch (std::out_of_range& e) {
88345       {
88346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88347       };
88348     } catch (std::exception& e) {
88349       {
88350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88351       };
88352     } catch (Dali::DaliException e) {
88353       {
88354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88355       };
88356     } catch (...) {
88357       {
88358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88359       };
88360     }
88361   }
88362
88363   jresult = (void *)result;
88364   return jresult;
88365 }
88366
88367
88368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88369   void * jresult ;
88370   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88371   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88372
88373   arg1 = (Dali::Toolkit::Popup *)jarg1;
88374   {
88375     try {
88376       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88377     } catch (std::out_of_range& e) {
88378       {
88379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88380       };
88381     } catch (std::exception& e) {
88382       {
88383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88384       };
88385     } catch (Dali::DaliException e) {
88386       {
88387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88388       };
88389     } catch (...) {
88390       {
88391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88392       };
88393     }
88394   }
88395
88396   jresult = (void *)result;
88397   return jresult;
88398 }
88399
88400
88401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88402   int jresult ;
88403   int result;
88404
88405   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88406   jresult = (int)result;
88407   return jresult;
88408 }
88409
88410
88411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88412   int jresult ;
88413   int result;
88414
88415   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88416   jresult = (int)result;
88417   return jresult;
88418 }
88419
88420
88421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88422   int jresult ;
88423   int result;
88424
88425   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88426   jresult = (int)result;
88427   return jresult;
88428 }
88429
88430
88431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88432   int jresult ;
88433   int result;
88434
88435   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88436   jresult = (int)result;
88437   return jresult;
88438 }
88439
88440
88441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88442   int jresult ;
88443   int result;
88444
88445   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88446   jresult = (int)result;
88447   return jresult;
88448 }
88449
88450
88451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88452   int jresult ;
88453   int result;
88454
88455   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88456   jresult = (int)result;
88457   return jresult;
88458 }
88459
88460
88461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88462   int jresult ;
88463   int result;
88464
88465   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88466   jresult = (int)result;
88467   return jresult;
88468 }
88469
88470
88471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88472   int jresult ;
88473   int result;
88474
88475   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88476   jresult = (int)result;
88477   return jresult;
88478 }
88479
88480
88481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88482   int jresult ;
88483   int result;
88484
88485   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88486   jresult = (int)result;
88487   return jresult;
88488 }
88489
88490
88491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88492   void * jresult ;
88493   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88494
88495   {
88496     try {
88497       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88498     } catch (std::out_of_range& e) {
88499       {
88500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88501       };
88502     } catch (std::exception& e) {
88503       {
88504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88505       };
88506     } catch (Dali::DaliException e) {
88507       {
88508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88509       };
88510     } catch (...) {
88511       {
88512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88513       };
88514     }
88515   }
88516
88517   jresult = (void *)result;
88518   return jresult;
88519 }
88520
88521
88522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88523   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88524
88525   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88526   {
88527     try {
88528       delete arg1;
88529     } catch (std::out_of_range& e) {
88530       {
88531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88532       };
88533     } catch (std::exception& e) {
88534       {
88535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88536       };
88537     } catch (Dali::DaliException e) {
88538       {
88539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88540       };
88541     } catch (...) {
88542       {
88543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88544       };
88545     }
88546   }
88547
88548 }
88549
88550
88551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88552   void * jresult ;
88553   Dali::Toolkit::ProgressBar result;
88554
88555   {
88556     try {
88557       result = Dali::Toolkit::ProgressBar::New();
88558     } catch (std::out_of_range& e) {
88559       {
88560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88561       };
88562     } catch (std::exception& e) {
88563       {
88564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88565       };
88566     } catch (Dali::DaliException e) {
88567       {
88568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88569       };
88570     } catch (...) {
88571       {
88572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88573       };
88574     }
88575   }
88576
88577   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88578   return jresult;
88579 }
88580
88581
88582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88583   void * jresult ;
88584   Dali::Toolkit::ProgressBar *result = 0 ;
88585
88586   {
88587     try {
88588       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88589     } catch (std::out_of_range& e) {
88590       {
88591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88592       };
88593     } catch (std::exception& e) {
88594       {
88595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88596       };
88597     } catch (Dali::DaliException e) {
88598       {
88599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88600       };
88601     } catch (...) {
88602       {
88603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88604       };
88605     }
88606   }
88607
88608   jresult = (void *)result;
88609   return jresult;
88610 }
88611
88612
88613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88614   void * jresult ;
88615   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88616   Dali::Toolkit::ProgressBar *result = 0 ;
88617
88618   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88619   if (!arg1) {
88620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88621     return 0;
88622   }
88623   {
88624     try {
88625       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88626     } catch (std::out_of_range& e) {
88627       {
88628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88629       };
88630     } catch (std::exception& e) {
88631       {
88632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88633       };
88634     } catch (Dali::DaliException e) {
88635       {
88636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88637       };
88638     } catch (...) {
88639       {
88640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88641       };
88642     }
88643   }
88644
88645   jresult = (void *)result;
88646   return jresult;
88647 }
88648
88649
88650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88651   void * jresult ;
88652   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88653   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88654   Dali::Toolkit::ProgressBar *result = 0 ;
88655
88656   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88657   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88658   if (!arg2) {
88659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88660     return 0;
88661   }
88662   {
88663     try {
88664       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88665     } catch (std::out_of_range& e) {
88666       {
88667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88668       };
88669     } catch (std::exception& e) {
88670       {
88671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88672       };
88673     } catch (Dali::DaliException e) {
88674       {
88675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88676       };
88677     } catch (...) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88680       };
88681     }
88682   }
88683
88684   jresult = (void *)result;
88685   return jresult;
88686 }
88687
88688
88689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88690   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88691
88692   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88693   {
88694     try {
88695       delete arg1;
88696     } catch (std::out_of_range& e) {
88697       {
88698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88699       };
88700     } catch (std::exception& e) {
88701       {
88702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88703       };
88704     } catch (Dali::DaliException e) {
88705       {
88706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88707       };
88708     } catch (...) {
88709       {
88710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88711       };
88712     }
88713   }
88714
88715 }
88716
88717
88718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88719   void * jresult ;
88720   Dali::BaseHandle arg1 ;
88721   Dali::BaseHandle *argp1 ;
88722   Dali::Toolkit::ProgressBar result;
88723
88724   argp1 = (Dali::BaseHandle *)jarg1;
88725   if (!argp1) {
88726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88727     return 0;
88728   }
88729   arg1 = *argp1;
88730   {
88731     try {
88732       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88733     } catch (std::out_of_range& e) {
88734       {
88735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88736       };
88737     } catch (std::exception& e) {
88738       {
88739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88740       };
88741     } catch (Dali::DaliException e) {
88742       {
88743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88744       };
88745     } catch (...) {
88746       {
88747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88748       };
88749     }
88750   }
88751
88752   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88753   return jresult;
88754 }
88755
88756
88757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88758   void * jresult ;
88759   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88760   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88761
88762   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88763   {
88764     try {
88765       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88766     } catch (std::out_of_range& e) {
88767       {
88768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88769       };
88770     } catch (std::exception& e) {
88771       {
88772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88773       };
88774     } catch (Dali::DaliException e) {
88775       {
88776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88777       };
88778     } catch (...) {
88779       {
88780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88781       };
88782     }
88783   }
88784
88785   jresult = (void *)result;
88786   return jresult;
88787 }
88788
88789
88790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88791   void * jresult ;
88792   Dali::Toolkit::GaussianBlurView *result = 0 ;
88793
88794   {
88795     try {
88796       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88797     } catch (std::out_of_range& e) {
88798       {
88799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88800       };
88801     } catch (std::exception& e) {
88802       {
88803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88804       };
88805     } catch (Dali::DaliException e) {
88806       {
88807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88808       };
88809     } catch (...) {
88810       {
88811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88812       };
88813     }
88814   }
88815
88816   jresult = (void *)result;
88817   return jresult;
88818 }
88819
88820
88821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88822   void * jresult ;
88823   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88824   Dali::Toolkit::GaussianBlurView *result = 0 ;
88825
88826   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88827   if (!arg1) {
88828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88829     return 0;
88830   }
88831   {
88832     try {
88833       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88834     } catch (std::out_of_range& e) {
88835       {
88836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88837       };
88838     } catch (std::exception& e) {
88839       {
88840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88841       };
88842     } catch (Dali::DaliException e) {
88843       {
88844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88845       };
88846     } catch (...) {
88847       {
88848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88849       };
88850     }
88851   }
88852
88853   jresult = (void *)result;
88854   return jresult;
88855 }
88856
88857
88858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88859   void * jresult ;
88860   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88861   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88862   Dali::Toolkit::GaussianBlurView *result = 0 ;
88863
88864   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88865   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88866   if (!arg2) {
88867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88868     return 0;
88869   }
88870   {
88871     try {
88872       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88873     } catch (std::out_of_range& e) {
88874       {
88875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88876       };
88877     } catch (std::exception& e) {
88878       {
88879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88880       };
88881     } catch (Dali::DaliException e) {
88882       {
88883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88884       };
88885     } catch (...) {
88886       {
88887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88888       };
88889     }
88890   }
88891
88892   jresult = (void *)result;
88893   return jresult;
88894 }
88895
88896
88897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88898   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88899
88900   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88901   {
88902     try {
88903       delete arg1;
88904     } catch (std::out_of_range& e) {
88905       {
88906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88907       };
88908     } catch (std::exception& e) {
88909       {
88910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88911       };
88912     } catch (Dali::DaliException e) {
88913       {
88914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88915       };
88916     } catch (...) {
88917       {
88918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88919       };
88920     }
88921   }
88922
88923 }
88924
88925
88926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88927   void * jresult ;
88928   Dali::BaseHandle arg1 ;
88929   Dali::BaseHandle *argp1 ;
88930   Dali::Toolkit::GaussianBlurView result;
88931
88932   argp1 = (Dali::BaseHandle *)jarg1;
88933   if (!argp1) {
88934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88935     return 0;
88936   }
88937   arg1 = *argp1;
88938   {
88939     try {
88940       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88941     } catch (std::out_of_range& e) {
88942       {
88943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88944       };
88945     } catch (std::exception& e) {
88946       {
88947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88948       };
88949     } catch (Dali::DaliException e) {
88950       {
88951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88952       };
88953     } catch (...) {
88954       {
88955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88956       };
88957     }
88958   }
88959
88960   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88961   return jresult;
88962 }
88963
88964
88965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88966   void * jresult ;
88967   Dali::Toolkit::GaussianBlurView result;
88968
88969   {
88970     try {
88971       result = Dali::Toolkit::GaussianBlurView::New();
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_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88997   void * jresult ;
88998   unsigned int arg1 ;
88999   float arg2 ;
89000   Dali::Pixel::Format arg3 ;
89001   float arg4 ;
89002   float arg5 ;
89003   bool arg6 ;
89004   Dali::Toolkit::GaussianBlurView result;
89005
89006   arg1 = (unsigned int)jarg1;
89007   arg2 = (float)jarg2;
89008   arg3 = (Dali::Pixel::Format)jarg3;
89009   arg4 = (float)jarg4;
89010   arg5 = (float)jarg5;
89011   arg6 = jarg6 ? true : false;
89012   {
89013     try {
89014       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89015     } catch (std::out_of_range& e) {
89016       {
89017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89018       };
89019     } catch (std::exception& e) {
89020       {
89021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89022       };
89023     } catch (Dali::DaliException e) {
89024       {
89025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89026       };
89027     } catch (...) {
89028       {
89029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89030       };
89031     }
89032   }
89033
89034   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89035   return jresult;
89036 }
89037
89038
89039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89040   void * jresult ;
89041   unsigned int arg1 ;
89042   float arg2 ;
89043   Dali::Pixel::Format arg3 ;
89044   float arg4 ;
89045   float arg5 ;
89046   Dali::Toolkit::GaussianBlurView result;
89047
89048   arg1 = (unsigned int)jarg1;
89049   arg2 = (float)jarg2;
89050   arg3 = (Dali::Pixel::Format)jarg3;
89051   arg4 = (float)jarg4;
89052   arg5 = (float)jarg5;
89053   {
89054     try {
89055       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89056     } catch (std::out_of_range& e) {
89057       {
89058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89059       };
89060     } catch (std::exception& e) {
89061       {
89062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89063       };
89064     } catch (Dali::DaliException e) {
89065       {
89066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89067       };
89068     } catch (...) {
89069       {
89070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89071       };
89072     }
89073   }
89074
89075   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89076   return jresult;
89077 }
89078
89079
89080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89081   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89082   Dali::Actor arg2 ;
89083   Dali::Actor *argp2 ;
89084
89085   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89086   argp2 = (Dali::Actor *)jarg2;
89087   if (!argp2) {
89088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89089     return ;
89090   }
89091   arg2 = *argp2;
89092   {
89093     try {
89094       (arg1)->Add(arg2);
89095     } catch (std::out_of_range& e) {
89096       {
89097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89098       };
89099     } catch (std::exception& e) {
89100       {
89101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89102       };
89103     } catch (Dali::DaliException e) {
89104       {
89105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89106       };
89107     } catch (...) {
89108       {
89109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89110       };
89111     }
89112   }
89113
89114 }
89115
89116
89117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89118   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89119   Dali::Actor arg2 ;
89120   Dali::Actor *argp2 ;
89121
89122   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89123   argp2 = (Dali::Actor *)jarg2;
89124   if (!argp2) {
89125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89126     return ;
89127   }
89128   arg2 = *argp2;
89129   {
89130     try {
89131       (arg1)->Remove(arg2);
89132     } catch (std::out_of_range& e) {
89133       {
89134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89135       };
89136     } catch (std::exception& e) {
89137       {
89138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89139       };
89140     } catch (Dali::DaliException e) {
89141       {
89142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89143       };
89144     } catch (...) {
89145       {
89146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89147       };
89148     }
89149   }
89150
89151 }
89152
89153
89154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89155   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89156
89157   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89158   {
89159     try {
89160       (arg1)->Activate();
89161     } catch (std::out_of_range& e) {
89162       {
89163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89164       };
89165     } catch (std::exception& e) {
89166       {
89167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89168       };
89169     } catch (Dali::DaliException e) {
89170       {
89171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89172       };
89173     } catch (...) {
89174       {
89175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89176       };
89177     }
89178   }
89179
89180 }
89181
89182
89183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89184   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89185
89186   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89187   {
89188     try {
89189       (arg1)->ActivateOnce();
89190     } catch (std::out_of_range& e) {
89191       {
89192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89193       };
89194     } catch (std::exception& e) {
89195       {
89196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89197       };
89198     } catch (Dali::DaliException e) {
89199       {
89200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89201       };
89202     } catch (...) {
89203       {
89204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89205       };
89206     }
89207   }
89208
89209 }
89210
89211
89212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89213   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89214
89215   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89216   {
89217     try {
89218       (arg1)->Deactivate();
89219     } catch (std::out_of_range& e) {
89220       {
89221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89222       };
89223     } catch (std::exception& e) {
89224       {
89225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89226       };
89227     } catch (Dali::DaliException e) {
89228       {
89229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89230       };
89231     } catch (...) {
89232       {
89233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89234       };
89235     }
89236   }
89237
89238 }
89239
89240
89241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89242   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89243   Dali::Texture arg2 ;
89244   Dali::FrameBuffer arg3 ;
89245   Dali::Texture *argp2 ;
89246   Dali::FrameBuffer *argp3 ;
89247
89248   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89249   argp2 = (Dali::Texture *)jarg2;
89250   if (!argp2) {
89251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
89252     return ;
89253   }
89254   arg2 = *argp2;
89255   argp3 = (Dali::FrameBuffer *)jarg3;
89256   if (!argp3) {
89257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
89258     return ;
89259   }
89260   arg3 = *argp3;
89261   {
89262     try {
89263       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89264     } catch (std::out_of_range& e) {
89265       {
89266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89267       };
89268     } catch (std::exception& e) {
89269       {
89270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89271       };
89272     } catch (Dali::DaliException e) {
89273       {
89274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89275       };
89276     } catch (...) {
89277       {
89278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89279       };
89280     }
89281   }
89282
89283 }
89284
89285
89286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89287   int jresult ;
89288   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89289   Dali::Property::Index result;
89290
89291   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89292   {
89293     try {
89294       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89295     } catch (std::out_of_range& e) {
89296       {
89297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89298       };
89299     } catch (std::exception& e) {
89300       {
89301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89302       };
89303     } catch (Dali::DaliException e) {
89304       {
89305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89306       };
89307     } catch (...) {
89308       {
89309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89310       };
89311     }
89312   }
89313
89314   jresult = result;
89315   return jresult;
89316 }
89317
89318
89319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89320   void * jresult ;
89321   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89322   Dali::FrameBuffer result;
89323
89324   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89325   {
89326     try {
89327       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89328     } catch (std::out_of_range& e) {
89329       {
89330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89331       };
89332     } catch (std::exception& e) {
89333       {
89334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89335       };
89336     } catch (Dali::DaliException e) {
89337       {
89338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89339       };
89340     } catch (...) {
89341       {
89342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89343       };
89344     }
89345   }
89346
89347   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
89348   return jresult;
89349 }
89350
89351
89352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89353   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89354   Dali::Vector4 *arg2 = 0 ;
89355
89356   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89357   arg2 = (Dali::Vector4 *)jarg2;
89358   if (!arg2) {
89359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89360     return ;
89361   }
89362   {
89363     try {
89364       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89365     } catch (std::out_of_range& e) {
89366       {
89367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89368       };
89369     } catch (std::exception& e) {
89370       {
89371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89372       };
89373     } catch (Dali::DaliException e) {
89374       {
89375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89376       };
89377     } catch (...) {
89378       {
89379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89380       };
89381     }
89382   }
89383
89384 }
89385
89386
89387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89388   void * jresult ;
89389   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89390   Dali::Vector4 result;
89391
89392   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89393   {
89394     try {
89395       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89396     } catch (std::out_of_range& e) {
89397       {
89398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89399       };
89400     } catch (std::exception& e) {
89401       {
89402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89403       };
89404     } catch (Dali::DaliException e) {
89405       {
89406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89407       };
89408     } catch (...) {
89409       {
89410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89411       };
89412     }
89413   }
89414
89415   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89416   return jresult;
89417 }
89418
89419
89420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89421   void * jresult ;
89422   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89423   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89424
89425   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89426   {
89427     try {
89428       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89429     } catch (std::out_of_range& e) {
89430       {
89431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89432       };
89433     } catch (std::exception& e) {
89434       {
89435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89436       };
89437     } catch (Dali::DaliException e) {
89438       {
89439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89440       };
89441     } catch (...) {
89442       {
89443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89444       };
89445     }
89446   }
89447
89448   jresult = (void *)result;
89449   return jresult;
89450 }
89451
89452
89453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89454   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89455
89456   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89457   {
89458     try {
89459       delete arg1;
89460     } catch (std::out_of_range& e) {
89461       {
89462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89463       };
89464     } catch (std::exception& e) {
89465       {
89466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89467       };
89468     } catch (Dali::DaliException e) {
89469       {
89470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89471       };
89472     } catch (...) {
89473       {
89474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89475       };
89476     }
89477   }
89478
89479 }
89480
89481
89482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89483   unsigned int jresult ;
89484   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89485   unsigned int result;
89486
89487   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89488   {
89489     try {
89490       result = (unsigned int)(arg1)->GetNumberOfPages();
89491     } catch (std::out_of_range& e) {
89492       {
89493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89494       };
89495     } catch (std::exception& e) {
89496       {
89497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89498       };
89499     } catch (Dali::DaliException e) {
89500       {
89501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89502       };
89503     } catch (...) {
89504       {
89505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89506       };
89507     }
89508   }
89509
89510   jresult = result;
89511   return jresult;
89512 }
89513
89514
89515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89516   void * jresult ;
89517   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89518   unsigned int arg2 ;
89519   Dali::Texture result;
89520
89521   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89522   arg2 = (unsigned int)jarg2;
89523   {
89524     try {
89525       result = (arg1)->NewPage(arg2);
89526     } catch (std::out_of_range& e) {
89527       {
89528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89529       };
89530     } catch (std::exception& e) {
89531       {
89532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89533       };
89534     } catch (Dali::DaliException e) {
89535       {
89536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89537       };
89538     } catch (...) {
89539       {
89540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89541       };
89542     }
89543   }
89544
89545   jresult = new Dali::Texture((const Dali::Texture &)result);
89546   return jresult;
89547 }
89548
89549
89550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
89551   int jresult ;
89552   int result;
89553
89554   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
89555   jresult = (int)result;
89556   return jresult;
89557 }
89558
89559
89560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89561   int jresult ;
89562   int result;
89563
89564   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89565   jresult = (int)result;
89566   return jresult;
89567 }
89568
89569
89570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89571   int jresult ;
89572   int result;
89573
89574   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89575   jresult = (int)result;
89576   return jresult;
89577 }
89578
89579
89580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89581   void * jresult ;
89582   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89583
89584   {
89585     try {
89586       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89587     } catch (std::out_of_range& e) {
89588       {
89589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89590       };
89591     } catch (std::exception& e) {
89592       {
89593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89594       };
89595     } catch (Dali::DaliException e) {
89596       {
89597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89598       };
89599     } catch (...) {
89600       {
89601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89602       };
89603     }
89604   }
89605
89606   jresult = (void *)result;
89607   return jresult;
89608 }
89609
89610
89611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89612   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89613
89614   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89615   {
89616     try {
89617       delete arg1;
89618     } catch (std::out_of_range& e) {
89619       {
89620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89621       };
89622     } catch (std::exception& e) {
89623       {
89624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89625       };
89626     } catch (Dali::DaliException e) {
89627       {
89628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89629       };
89630     } catch (...) {
89631       {
89632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89633       };
89634     }
89635   }
89636
89637 }
89638
89639
89640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89641   void * jresult ;
89642   Dali::Toolkit::PageTurnView *result = 0 ;
89643
89644   {
89645     try {
89646       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89647     } catch (std::out_of_range& e) {
89648       {
89649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89650       };
89651     } catch (std::exception& e) {
89652       {
89653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89654       };
89655     } catch (Dali::DaliException e) {
89656       {
89657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89658       };
89659     } catch (...) {
89660       {
89661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89662       };
89663     }
89664   }
89665
89666   jresult = (void *)result;
89667   return jresult;
89668 }
89669
89670
89671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89672   void * jresult ;
89673   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89674   Dali::Toolkit::PageTurnView *result = 0 ;
89675
89676   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89677   if (!arg1) {
89678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89679     return 0;
89680   }
89681   {
89682     try {
89683       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89684     } catch (std::out_of_range& e) {
89685       {
89686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89687       };
89688     } catch (std::exception& e) {
89689       {
89690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89691       };
89692     } catch (Dali::DaliException e) {
89693       {
89694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89695       };
89696     } catch (...) {
89697       {
89698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89699       };
89700     }
89701   }
89702
89703   jresult = (void *)result;
89704   return jresult;
89705 }
89706
89707
89708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89709   void * jresult ;
89710   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89711   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89712   Dali::Toolkit::PageTurnView *result = 0 ;
89713
89714   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89715   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89716   if (!arg2) {
89717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89718     return 0;
89719   }
89720   {
89721     try {
89722       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89723     } catch (std::out_of_range& e) {
89724       {
89725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89726       };
89727     } catch (std::exception& e) {
89728       {
89729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89730       };
89731     } catch (Dali::DaliException e) {
89732       {
89733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89734       };
89735     } catch (...) {
89736       {
89737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89738       };
89739     }
89740   }
89741
89742   jresult = (void *)result;
89743   return jresult;
89744 }
89745
89746
89747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89748   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89749
89750   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89751   {
89752     try {
89753       delete arg1;
89754     } catch (std::out_of_range& e) {
89755       {
89756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89757       };
89758     } catch (std::exception& e) {
89759       {
89760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89761       };
89762     } catch (Dali::DaliException e) {
89763       {
89764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89765       };
89766     } catch (...) {
89767       {
89768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89769       };
89770     }
89771   }
89772
89773 }
89774
89775
89776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89777   void * jresult ;
89778   Dali::BaseHandle arg1 ;
89779   Dali::BaseHandle *argp1 ;
89780   Dali::Toolkit::PageTurnView result;
89781
89782   argp1 = (Dali::BaseHandle *)jarg1;
89783   if (!argp1) {
89784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89785     return 0;
89786   }
89787   arg1 = *argp1;
89788   {
89789     try {
89790       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89791     } catch (std::out_of_range& e) {
89792       {
89793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89794       };
89795     } catch (std::exception& e) {
89796       {
89797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89798       };
89799     } catch (Dali::DaliException e) {
89800       {
89801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89802       };
89803     } catch (...) {
89804       {
89805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89806       };
89807     }
89808   }
89809
89810   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89811   return jresult;
89812 }
89813
89814
89815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89816   void * jresult ;
89817   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89818   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89819
89820   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89821   {
89822     try {
89823       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89824     } catch (std::out_of_range& e) {
89825       {
89826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89827       };
89828     } catch (std::exception& e) {
89829       {
89830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89831       };
89832     } catch (Dali::DaliException e) {
89833       {
89834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89835       };
89836     } catch (...) {
89837       {
89838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89839       };
89840     }
89841   }
89842
89843   jresult = (void *)result;
89844   return jresult;
89845 }
89846
89847
89848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89849   void * jresult ;
89850   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89851   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89852
89853   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89854   {
89855     try {
89856       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89857     } catch (std::out_of_range& e) {
89858       {
89859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89860       };
89861     } catch (std::exception& e) {
89862       {
89863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89864       };
89865     } catch (Dali::DaliException e) {
89866       {
89867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89868       };
89869     } catch (...) {
89870       {
89871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89872       };
89873     }
89874   }
89875
89876   jresult = (void *)result;
89877   return jresult;
89878 }
89879
89880
89881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89882   void * jresult ;
89883   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89884   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89885
89886   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89887   {
89888     try {
89889       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89890     } catch (std::out_of_range& e) {
89891       {
89892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89893       };
89894     } catch (std::exception& e) {
89895       {
89896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89897       };
89898     } catch (Dali::DaliException e) {
89899       {
89900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89901       };
89902     } catch (...) {
89903       {
89904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89905       };
89906     }
89907   }
89908
89909   jresult = (void *)result;
89910   return jresult;
89911 }
89912
89913
89914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89915   void * jresult ;
89916   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89917   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89918
89919   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89920   {
89921     try {
89922       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89923     } catch (std::out_of_range& e) {
89924       {
89925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89926       };
89927     } catch (std::exception& e) {
89928       {
89929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89930       };
89931     } catch (Dali::DaliException e) {
89932       {
89933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89934       };
89935     } catch (...) {
89936       {
89937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89938       };
89939     }
89940   }
89941
89942   jresult = (void *)result;
89943   return jresult;
89944 }
89945
89946
89947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89948   void * jresult ;
89949   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89950
89951   {
89952     try {
89953       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89954     } catch (std::out_of_range& e) {
89955       {
89956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89957       };
89958     } catch (std::exception& e) {
89959       {
89960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89961       };
89962     } catch (Dali::DaliException e) {
89963       {
89964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89965       };
89966     } catch (...) {
89967       {
89968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89969       };
89970     }
89971   }
89972
89973   jresult = (void *)result;
89974   return jresult;
89975 }
89976
89977
89978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89979   void * jresult ;
89980   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89981   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89982
89983   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89984   if (!arg1) {
89985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89986     return 0;
89987   }
89988   {
89989     try {
89990       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89991     } catch (std::out_of_range& e) {
89992       {
89993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89994       };
89995     } catch (std::exception& e) {
89996       {
89997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89998       };
89999     } catch (Dali::DaliException e) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90002       };
90003     } catch (...) {
90004       {
90005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90006       };
90007     }
90008   }
90009
90010   jresult = (void *)result;
90011   return jresult;
90012 }
90013
90014
90015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90016   void * jresult ;
90017   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90018   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90019   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90020
90021   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90022   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90023   if (!arg2) {
90024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90025     return 0;
90026   }
90027   {
90028     try {
90029       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90030     } catch (std::out_of_range& e) {
90031       {
90032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90033       };
90034     } catch (std::exception& e) {
90035       {
90036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90037       };
90038     } catch (Dali::DaliException e) {
90039       {
90040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90041       };
90042     } catch (...) {
90043       {
90044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90045       };
90046     }
90047   }
90048
90049   jresult = (void *)result;
90050   return jresult;
90051 }
90052
90053
90054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90055   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90056
90057   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90058   {
90059     try {
90060       delete arg1;
90061     } catch (std::out_of_range& e) {
90062       {
90063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90064       };
90065     } catch (std::exception& e) {
90066       {
90067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90068       };
90069     } catch (Dali::DaliException e) {
90070       {
90071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90072       };
90073     } catch (...) {
90074       {
90075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90076       };
90077     }
90078   }
90079
90080 }
90081
90082
90083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90084   void * jresult ;
90085   Dali::Toolkit::PageFactory *arg1 = 0 ;
90086   Dali::Vector2 *arg2 = 0 ;
90087   Dali::Toolkit::PageTurnLandscapeView result;
90088
90089   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90090   if (!arg1) {
90091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90092     return 0;
90093   }
90094   arg2 = (Dali::Vector2 *)jarg2;
90095   if (!arg2) {
90096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90097     return 0;
90098   }
90099   {
90100     try {
90101       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90102     } catch (std::out_of_range& e) {
90103       {
90104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90105       };
90106     } catch (std::exception& e) {
90107       {
90108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90109       };
90110     } catch (Dali::DaliException e) {
90111       {
90112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90113       };
90114     } catch (...) {
90115       {
90116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90117       };
90118     }
90119   }
90120
90121   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90122   return jresult;
90123 }
90124
90125
90126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90127   void * jresult ;
90128   Dali::BaseHandle arg1 ;
90129   Dali::BaseHandle *argp1 ;
90130   Dali::Toolkit::PageTurnLandscapeView result;
90131
90132   argp1 = (Dali::BaseHandle *)jarg1;
90133   if (!argp1) {
90134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90135     return 0;
90136   }
90137   arg1 = *argp1;
90138   {
90139     try {
90140       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90141     } catch (std::out_of_range& e) {
90142       {
90143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90144       };
90145     } catch (std::exception& e) {
90146       {
90147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90148       };
90149     } catch (Dali::DaliException e) {
90150       {
90151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90152       };
90153     } catch (...) {
90154       {
90155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90156       };
90157     }
90158   }
90159
90160   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90161   return jresult;
90162 }
90163
90164
90165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90166   void * jresult ;
90167   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90168
90169   {
90170     try {
90171       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90172     } catch (std::out_of_range& e) {
90173       {
90174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90175       };
90176     } catch (std::exception& e) {
90177       {
90178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90179       };
90180     } catch (Dali::DaliException e) {
90181       {
90182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90183       };
90184     } catch (...) {
90185       {
90186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90187       };
90188     }
90189   }
90190
90191   jresult = (void *)result;
90192   return jresult;
90193 }
90194
90195
90196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90197   void * jresult ;
90198   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90199   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90200
90201   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90202   if (!arg1) {
90203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90204     return 0;
90205   }
90206   {
90207     try {
90208       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90209     } catch (std::out_of_range& e) {
90210       {
90211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90212       };
90213     } catch (std::exception& e) {
90214       {
90215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90216       };
90217     } catch (Dali::DaliException e) {
90218       {
90219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90220       };
90221     } catch (...) {
90222       {
90223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90224       };
90225     }
90226   }
90227
90228   jresult = (void *)result;
90229   return jresult;
90230 }
90231
90232
90233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90234   void * jresult ;
90235   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90236   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90237   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90238
90239   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90240   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90241   if (!arg2) {
90242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90243     return 0;
90244   }
90245   {
90246     try {
90247       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90248     } catch (std::out_of_range& e) {
90249       {
90250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90251       };
90252     } catch (std::exception& e) {
90253       {
90254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90255       };
90256     } catch (Dali::DaliException e) {
90257       {
90258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90259       };
90260     } catch (...) {
90261       {
90262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90263       };
90264     }
90265   }
90266
90267   jresult = (void *)result;
90268   return jresult;
90269 }
90270
90271
90272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90273   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90274
90275   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90276   {
90277     try {
90278       delete arg1;
90279     } catch (std::out_of_range& e) {
90280       {
90281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90282       };
90283     } catch (std::exception& e) {
90284       {
90285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90286       };
90287     } catch (Dali::DaliException e) {
90288       {
90289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90290       };
90291     } catch (...) {
90292       {
90293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90294       };
90295     }
90296   }
90297
90298 }
90299
90300
90301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90302   void * jresult ;
90303   Dali::Toolkit::PageFactory *arg1 = 0 ;
90304   Dali::Vector2 *arg2 = 0 ;
90305   Dali::Toolkit::PageTurnPortraitView result;
90306
90307   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90308   if (!arg1) {
90309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90310     return 0;
90311   }
90312   arg2 = (Dali::Vector2 *)jarg2;
90313   if (!arg2) {
90314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90315     return 0;
90316   }
90317   {
90318     try {
90319       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90320     } catch (std::out_of_range& e) {
90321       {
90322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90323       };
90324     } catch (std::exception& e) {
90325       {
90326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90327       };
90328     } catch (Dali::DaliException e) {
90329       {
90330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90331       };
90332     } catch (...) {
90333       {
90334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90335       };
90336     }
90337   }
90338
90339   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90340   return jresult;
90341 }
90342
90343
90344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90345   void * jresult ;
90346   Dali::BaseHandle arg1 ;
90347   Dali::BaseHandle *argp1 ;
90348   Dali::Toolkit::PageTurnPortraitView result;
90349
90350   argp1 = (Dali::BaseHandle *)jarg1;
90351   if (!argp1) {
90352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90353     return 0;
90354   }
90355   arg1 = *argp1;
90356   {
90357     try {
90358       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90359     } catch (std::out_of_range& e) {
90360       {
90361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90362       };
90363     } catch (std::exception& e) {
90364       {
90365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90366       };
90367     } catch (Dali::DaliException e) {
90368       {
90369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90370       };
90371     } catch (...) {
90372       {
90373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90374       };
90375     }
90376   }
90377
90378   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90379   return jresult;
90380 }
90381
90382
90383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90384   int jresult ;
90385   int result;
90386
90387   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90388   jresult = (int)result;
90389   return jresult;
90390 }
90391
90392
90393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90394   int jresult ;
90395   int result;
90396
90397   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90398   jresult = (int)result;
90399   return jresult;
90400 }
90401
90402
90403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90404   int jresult ;
90405   int result;
90406
90407   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90408   jresult = (int)result;
90409   return jresult;
90410 }
90411
90412
90413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90414   void * jresult ;
90415   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90416
90417   {
90418     try {
90419       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90420     } catch (std::out_of_range& e) {
90421       {
90422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90423       };
90424     } catch (std::exception& e) {
90425       {
90426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90427       };
90428     } catch (Dali::DaliException e) {
90429       {
90430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90431       };
90432     } catch (...) {
90433       {
90434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90435       };
90436     }
90437   }
90438
90439   jresult = (void *)result;
90440   return jresult;
90441 }
90442
90443
90444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90445   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90446
90447   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90448   {
90449     try {
90450       delete arg1;
90451     } catch (std::out_of_range& e) {
90452       {
90453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90454       };
90455     } catch (std::exception& e) {
90456       {
90457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90458       };
90459     } catch (Dali::DaliException e) {
90460       {
90461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90462       };
90463     } catch (...) {
90464       {
90465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90466       };
90467     }
90468   }
90469
90470 }
90471
90472
90473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90474   void * jresult ;
90475   Dali::Toolkit::ToggleButton *result = 0 ;
90476
90477   {
90478     try {
90479       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90480     } catch (std::out_of_range& e) {
90481       {
90482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90483       };
90484     } catch (std::exception& e) {
90485       {
90486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90487       };
90488     } catch (Dali::DaliException e) {
90489       {
90490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90491       };
90492     } catch (...) {
90493       {
90494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90495       };
90496     }
90497   }
90498
90499   jresult = (void *)result;
90500   return jresult;
90501 }
90502
90503
90504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90505   void * jresult ;
90506   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90507   Dali::Toolkit::ToggleButton *result = 0 ;
90508
90509   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90510   if (!arg1) {
90511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90512     return 0;
90513   }
90514   {
90515     try {
90516       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90517     } catch (std::out_of_range& e) {
90518       {
90519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90520       };
90521     } catch (std::exception& e) {
90522       {
90523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90524       };
90525     } catch (Dali::DaliException e) {
90526       {
90527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90528       };
90529     } catch (...) {
90530       {
90531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90532       };
90533     }
90534   }
90535
90536   jresult = (void *)result;
90537   return jresult;
90538 }
90539
90540
90541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90542   void * jresult ;
90543   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90544   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90545   Dali::Toolkit::ToggleButton *result = 0 ;
90546
90547   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90548   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90549   if (!arg2) {
90550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90551     return 0;
90552   }
90553   {
90554     try {
90555       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90556     } catch (std::out_of_range& e) {
90557       {
90558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90559       };
90560     } catch (std::exception& e) {
90561       {
90562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90563       };
90564     } catch (Dali::DaliException e) {
90565       {
90566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90567       };
90568     } catch (...) {
90569       {
90570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90571       };
90572     }
90573   }
90574
90575   jresult = (void *)result;
90576   return jresult;
90577 }
90578
90579
90580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90581   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90582
90583   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90584   {
90585     try {
90586       delete arg1;
90587     } catch (std::out_of_range& e) {
90588       {
90589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90590       };
90591     } catch (std::exception& e) {
90592       {
90593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90594       };
90595     } catch (Dali::DaliException e) {
90596       {
90597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90598       };
90599     } catch (...) {
90600       {
90601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90602       };
90603     }
90604   }
90605
90606 }
90607
90608
90609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90610   void * jresult ;
90611   Dali::Toolkit::ToggleButton result;
90612
90613   {
90614     try {
90615       result = Dali::Toolkit::ToggleButton::New();
90616     } catch (std::out_of_range& e) {
90617       {
90618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90619       };
90620     } catch (std::exception& e) {
90621       {
90622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90623       };
90624     } catch (Dali::DaliException e) {
90625       {
90626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90627       };
90628     } catch (...) {
90629       {
90630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90631       };
90632     }
90633   }
90634
90635   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90636   return jresult;
90637 }
90638
90639
90640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90641   void * jresult ;
90642   Dali::BaseHandle arg1 ;
90643   Dali::BaseHandle *argp1 ;
90644   Dali::Toolkit::ToggleButton result;
90645
90646   argp1 = (Dali::BaseHandle *)jarg1;
90647   if (!argp1) {
90648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90649     return 0;
90650   }
90651   arg1 = *argp1;
90652   {
90653     try {
90654       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90655     } catch (std::out_of_range& e) {
90656       {
90657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90658       };
90659     } catch (std::exception& e) {
90660       {
90661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90662       };
90663     } catch (Dali::DaliException e) {
90664       {
90665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90666       };
90667     } catch (...) {
90668       {
90669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90670       };
90671     }
90672   }
90673
90674   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90675   return jresult;
90676 }
90677
90678
90679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90680   void * jresult ;
90681   Dali::Toolkit::Visual::Base *result = 0 ;
90682
90683   {
90684     try {
90685       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90686     } catch (std::out_of_range& e) {
90687       {
90688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90689       };
90690     } catch (std::exception& e) {
90691       {
90692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90693       };
90694     } catch (Dali::DaliException e) {
90695       {
90696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90697       };
90698     } catch (...) {
90699       {
90700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90701       };
90702     }
90703   }
90704
90705   jresult = (void *)result;
90706   return jresult;
90707 }
90708
90709
90710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90711   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90712
90713   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90714   {
90715     try {
90716       delete arg1;
90717     } catch (std::out_of_range& e) {
90718       {
90719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90720       };
90721     } catch (std::exception& e) {
90722       {
90723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90724       };
90725     } catch (Dali::DaliException e) {
90726       {
90727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90728       };
90729     } catch (...) {
90730       {
90731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90732       };
90733     }
90734   }
90735
90736 }
90737
90738
90739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90740   void * jresult ;
90741   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90742   Dali::Toolkit::Visual::Base *result = 0 ;
90743
90744   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90745   if (!arg1) {
90746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90747     return 0;
90748   }
90749   {
90750     try {
90751       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90752     } catch (std::out_of_range& e) {
90753       {
90754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90755       };
90756     } catch (std::exception& e) {
90757       {
90758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90759       };
90760     } catch (Dali::DaliException e) {
90761       {
90762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90763       };
90764     } catch (...) {
90765       {
90766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90767       };
90768     }
90769   }
90770
90771   jresult = (void *)result;
90772   return jresult;
90773 }
90774
90775
90776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90777   void * jresult ;
90778   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90779   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90780   Dali::Toolkit::Visual::Base *result = 0 ;
90781
90782   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90783   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90784   if (!arg2) {
90785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90786     return 0;
90787   }
90788   {
90789     try {
90790       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90791     } catch (std::out_of_range& e) {
90792       {
90793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90794       };
90795     } catch (std::exception& e) {
90796       {
90797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90798       };
90799     } catch (Dali::DaliException e) {
90800       {
90801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90802       };
90803     } catch (...) {
90804       {
90805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90806       };
90807     }
90808   }
90809
90810   jresult = (void *)result;
90811   return jresult;
90812 }
90813
90814
90815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90816   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90817   std::string *arg2 = 0 ;
90818
90819   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90820   if (!jarg2) {
90821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90822     return ;
90823   }
90824   std::string arg2_str(jarg2);
90825   arg2 = &arg2_str;
90826   {
90827     try {
90828       (arg1)->SetName((std::string const &)*arg2);
90829     } catch (std::out_of_range& e) {
90830       {
90831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90832       };
90833     } catch (std::exception& e) {
90834       {
90835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90836       };
90837     } catch (Dali::DaliException e) {
90838       {
90839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90840       };
90841     } catch (...) {
90842       {
90843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90844       };
90845     }
90846   }
90847
90848
90849   //argout typemap for const std::string&
90850
90851 }
90852
90853
90854 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90855   char * jresult ;
90856   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90857   std::string *result = 0 ;
90858
90859   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90860   {
90861     try {
90862       result = (std::string *) &(arg1)->GetName();
90863     } catch (std::out_of_range& e) {
90864       {
90865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90866       };
90867     } catch (std::exception& e) {
90868       {
90869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90870       };
90871     } catch (Dali::DaliException e) {
90872       {
90873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90874       };
90875     } catch (...) {
90876       {
90877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90878       };
90879     }
90880   }
90881
90882   jresult = SWIG_csharp_string_callback(result->c_str());
90883   return jresult;
90884 }
90885
90886
90887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90888   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90889   Dali::Property::Map *arg2 = 0 ;
90890   Dali::Size arg3 ;
90891   Dali::Size *argp3 ;
90892
90893   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90894   arg2 = (Dali::Property::Map *)jarg2;
90895   if (!arg2) {
90896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90897     return ;
90898   }
90899   argp3 = (Dali::Size *)jarg3;
90900   if (!argp3) {
90901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90902     return ;
90903   }
90904   arg3 = *argp3;
90905   {
90906     try {
90907       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90915       };
90916     } catch (Dali::DaliException e) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90919       };
90920     } catch (...) {
90921       {
90922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90923       };
90924     }
90925   }
90926
90927 }
90928
90929
90930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90931   float jresult ;
90932   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90933   float arg2 ;
90934   float result;
90935
90936   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90937   arg2 = (float)jarg2;
90938   {
90939     try {
90940       result = (float)(arg1)->GetHeightForWidth(arg2);
90941     } catch (std::out_of_range& e) {
90942       {
90943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90944       };
90945     } catch (std::exception& e) {
90946       {
90947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90948       };
90949     } catch (Dali::DaliException e) {
90950       {
90951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90952       };
90953     } catch (...) {
90954       {
90955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90956       };
90957     }
90958   }
90959
90960   jresult = result;
90961   return jresult;
90962 }
90963
90964
90965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90966   float jresult ;
90967   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90968   float arg2 ;
90969   float result;
90970
90971   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90972   arg2 = (float)jarg2;
90973   {
90974     try {
90975       result = (float)(arg1)->GetWidthForHeight(arg2);
90976     } catch (std::out_of_range& e) {
90977       {
90978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90979       };
90980     } catch (std::exception& e) {
90981       {
90982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90983       };
90984     } catch (Dali::DaliException e) {
90985       {
90986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90987       };
90988     } catch (...) {
90989       {
90990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90991       };
90992     }
90993   }
90994
90995   jresult = result;
90996   return jresult;
90997 }
90998
90999
91000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91001   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91002   Dali::Vector2 *arg2 = 0 ;
91003
91004   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91005   arg2 = (Dali::Vector2 *)jarg2;
91006   if (!arg2) {
91007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91008     return ;
91009   }
91010   {
91011     try {
91012       (arg1)->GetNaturalSize(*arg2);
91013     } catch (std::out_of_range& e) {
91014       {
91015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91016       };
91017     } catch (std::exception& e) {
91018       {
91019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91020       };
91021     } catch (Dali::DaliException e) {
91022       {
91023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91024       };
91025     } catch (...) {
91026       {
91027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91028       };
91029     }
91030   }
91031
91032 }
91033
91034
91035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91036   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91037   float arg2 ;
91038
91039   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91040   arg2 = (int)jarg2;
91041   {
91042     try {
91043       (arg1)->SetDepthIndex(arg2);
91044     } catch (std::out_of_range& e) {
91045       {
91046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91047       };
91048     } catch (std::exception& e) {
91049       {
91050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91051       };
91052     } catch (Dali::DaliException e) {
91053       {
91054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91055       };
91056     } catch (...) {
91057       {
91058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91059       };
91060     }
91061   }
91062
91063 }
91064
91065
91066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91067   int jresult ;
91068   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91069   int result;
91070
91071   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91072   {
91073     try {
91074       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91075     } catch (std::out_of_range& e) {
91076       {
91077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91078       };
91079     } catch (std::exception& e) {
91080       {
91081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91082       };
91083     } catch (Dali::DaliException e) {
91084       {
91085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91086       };
91087     } catch (...) {
91088       {
91089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91090       };
91091     }
91092   }
91093
91094   jresult = result;
91095   return jresult;
91096 }
91097
91098
91099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91100   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91101   Dali::Property::Map *arg2 = 0 ;
91102
91103   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91104   arg2 = (Dali::Property::Map *)jarg2;
91105   if (!arg2) {
91106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91107     return ;
91108   }
91109   {
91110     try {
91111       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91112     } catch (std::out_of_range& e) {
91113       {
91114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91115       };
91116     } catch (std::exception& e) {
91117       {
91118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91119       };
91120     } catch (Dali::DaliException e) {
91121       {
91122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91123       };
91124     } catch (...) {
91125       {
91126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91127       };
91128     }
91129   }
91130
91131 }
91132
91133
91134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91135   void * jresult ;
91136   Dali::Toolkit::VisualFactory result;
91137
91138   {
91139     try {
91140       result = Dali::Toolkit::VisualFactory::Get();
91141     } catch (std::out_of_range& e) {
91142       {
91143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91144       };
91145     } catch (std::exception& e) {
91146       {
91147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91148       };
91149     } catch (Dali::DaliException e) {
91150       {
91151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91152       };
91153     } catch (...) {
91154       {
91155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91156       };
91157     }
91158   }
91159
91160   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91161   return jresult;
91162 }
91163
91164
91165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91166   void * jresult ;
91167   Dali::Toolkit::VisualFactory *result = 0 ;
91168
91169   {
91170     try {
91171       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91172     } catch (std::out_of_range& e) {
91173       {
91174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91175       };
91176     } catch (std::exception& e) {
91177       {
91178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91179       };
91180     } catch (Dali::DaliException e) {
91181       {
91182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91183       };
91184     } catch (...) {
91185       {
91186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91187       };
91188     }
91189   }
91190
91191   jresult = (void *)result;
91192   return jresult;
91193 }
91194
91195
91196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91197   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91198
91199   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91200   {
91201     try {
91202       delete arg1;
91203     } catch (std::out_of_range& e) {
91204       {
91205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91206       };
91207     } catch (std::exception& e) {
91208       {
91209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91210       };
91211     } catch (Dali::DaliException e) {
91212       {
91213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91214       };
91215     } catch (...) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91218       };
91219     }
91220   }
91221
91222 }
91223
91224
91225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91226   void * jresult ;
91227   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91228   Dali::Toolkit::VisualFactory *result = 0 ;
91229
91230   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91231   if (!arg1) {
91232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91233     return 0;
91234   }
91235   {
91236     try {
91237       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91238     } catch (std::out_of_range& e) {
91239       {
91240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91241       };
91242     } catch (std::exception& e) {
91243       {
91244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91245       };
91246     } catch (Dali::DaliException e) {
91247       {
91248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91249       };
91250     } catch (...) {
91251       {
91252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91253       };
91254     }
91255   }
91256
91257   jresult = (void *)result;
91258   return jresult;
91259 }
91260
91261
91262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91263   void * jresult ;
91264   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91265   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91266   Dali::Toolkit::VisualFactory *result = 0 ;
91267
91268   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91269   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91270   if (!arg2) {
91271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91272     return 0;
91273   }
91274   {
91275     try {
91276       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91277     } catch (std::out_of_range& e) {
91278       {
91279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91280       };
91281     } catch (std::exception& e) {
91282       {
91283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91284       };
91285     } catch (Dali::DaliException e) {
91286       {
91287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91288       };
91289     } catch (...) {
91290       {
91291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91292       };
91293     }
91294   }
91295
91296   jresult = (void *)result;
91297   return jresult;
91298 }
91299
91300
91301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91302   void * jresult ;
91303   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91304   Dali::Property::Map *arg2 = 0 ;
91305   Dali::Toolkit::Visual::Base result;
91306
91307   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91308   arg2 = (Dali::Property::Map *)jarg2;
91309   if (!arg2) {
91310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91311     return 0;
91312   }
91313   {
91314     try {
91315       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91316     } catch (std::out_of_range& e) {
91317       {
91318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91319       };
91320     } catch (std::exception& e) {
91321       {
91322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91323       };
91324     } catch (Dali::DaliException e) {
91325       {
91326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91327       };
91328     } catch (...) {
91329       {
91330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91331       };
91332     }
91333   }
91334
91335   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91336   return jresult;
91337 }
91338
91339
91340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91341   void * jresult ;
91342   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91343   Dali::Image *arg2 = 0 ;
91344   Dali::Toolkit::Visual::Base result;
91345
91346   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91347   arg2 = (Dali::Image *)jarg2;
91348   if (!arg2) {
91349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91350     return 0;
91351   }
91352   {
91353     try {
91354       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91355     } catch (std::out_of_range& e) {
91356       {
91357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91358       };
91359     } catch (std::exception& e) {
91360       {
91361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91362       };
91363     } catch (Dali::DaliException e) {
91364       {
91365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91366       };
91367     } catch (...) {
91368       {
91369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91370       };
91371     }
91372   }
91373
91374   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91375   return jresult;
91376 }
91377
91378
91379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91380   void * jresult ;
91381   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91382   std::string *arg2 = 0 ;
91383   Dali::ImageDimensions arg3 ;
91384   Dali::ImageDimensions *argp3 ;
91385   Dali::Toolkit::Visual::Base result;
91386
91387   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91388   if (!jarg2) {
91389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91390     return 0;
91391   }
91392   std::string arg2_str(jarg2);
91393   arg2 = &arg2_str;
91394   argp3 = (Dali::ImageDimensions *)jarg3;
91395   if (!argp3) {
91396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91397     return 0;
91398   }
91399   arg3 = *argp3;
91400   {
91401     try {
91402       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91403     } catch (std::out_of_range& e) {
91404       {
91405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91406       };
91407     } catch (std::exception& e) {
91408       {
91409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91410       };
91411     } catch (Dali::DaliException e) {
91412       {
91413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91414       };
91415     } catch (...) {
91416       {
91417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91418       };
91419     }
91420   }
91421
91422   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91423
91424   //argout typemap for const std::string&
91425
91426   return jresult;
91427 }
91428
91429
91430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91431   void * jresult ;
91432   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91433
91434   {
91435     try {
91436       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91437     } catch (std::out_of_range& e) {
91438       {
91439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91440       };
91441     } catch (std::exception& e) {
91442       {
91443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91444       };
91445     } catch (Dali::DaliException e) {
91446       {
91447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91448       };
91449     } catch (...) {
91450       {
91451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91452       };
91453     }
91454   }
91455
91456   jresult = (void *)result;
91457   return jresult;
91458 }
91459
91460
91461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91462   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91463
91464   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91465   {
91466     try {
91467       delete arg1;
91468     } catch (std::out_of_range& e) {
91469       {
91470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91471       };
91472     } catch (std::exception& e) {
91473       {
91474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91475       };
91476     } catch (Dali::DaliException e) {
91477       {
91478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91479       };
91480     } catch (...) {
91481       {
91482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91483       };
91484     }
91485   }
91486
91487 }
91488
91489
91490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91491   void * jresult ;
91492   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91493   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91494
91495   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91496   if (!arg1) {
91497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91498     return 0;
91499   }
91500   {
91501     try {
91502       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91503     } catch (std::out_of_range& e) {
91504       {
91505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91506       };
91507     } catch (std::exception& e) {
91508       {
91509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91510       };
91511     } catch (Dali::DaliException e) {
91512       {
91513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91514       };
91515     } catch (...) {
91516       {
91517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91518       };
91519     }
91520   }
91521
91522   jresult = (void *)result;
91523   return jresult;
91524 }
91525
91526
91527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91528   void * jresult ;
91529   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91530   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91531   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91532
91533   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91534   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91535   if (!arg2) {
91536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91537     return 0;
91538   }
91539   {
91540     try {
91541       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91542     } catch (std::out_of_range& e) {
91543       {
91544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91545       };
91546     } catch (std::exception& e) {
91547       {
91548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91549       };
91550     } catch (Dali::DaliException e) {
91551       {
91552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91553       };
91554     } catch (...) {
91555       {
91556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91557       };
91558     }
91559   }
91560
91561   jresult = (void *)result;
91562   return jresult;
91563 }
91564
91565
91566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91567   void * jresult ;
91568   Dali::Toolkit::AsyncImageLoader result;
91569
91570   {
91571     try {
91572       result = Dali::Toolkit::AsyncImageLoader::New();
91573     } catch (std::out_of_range& e) {
91574       {
91575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91576       };
91577     } catch (std::exception& e) {
91578       {
91579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91580       };
91581     } catch (Dali::DaliException e) {
91582       {
91583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91584       };
91585     } catch (...) {
91586       {
91587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91588       };
91589     }
91590   }
91591
91592   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91593   return jresult;
91594 }
91595
91596
91597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91598   void * jresult ;
91599   Dali::BaseHandle arg1 ;
91600   Dali::BaseHandle *argp1 ;
91601   Dali::Toolkit::AsyncImageLoader result;
91602
91603   argp1 = (Dali::BaseHandle *)jarg1;
91604   if (!argp1) {
91605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91606     return 0;
91607   }
91608   arg1 = *argp1;
91609   {
91610     try {
91611       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91612     } catch (std::out_of_range& e) {
91613       {
91614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91615       };
91616     } catch (std::exception& e) {
91617       {
91618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91619       };
91620     } catch (Dali::DaliException e) {
91621       {
91622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91623       };
91624     } catch (...) {
91625       {
91626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91627       };
91628     }
91629   }
91630
91631   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91632   return jresult;
91633 }
91634
91635
91636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91637   unsigned int jresult ;
91638   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91639   std::string *arg2 = 0 ;
91640   uint32_t result;
91641
91642   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91643   if (!jarg2) {
91644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91645     return 0;
91646   }
91647   std::string arg2_str(jarg2);
91648   arg2 = &arg2_str;
91649   {
91650     try {
91651       result = (arg1)->Load((std::string const &)*arg2);
91652     } catch (std::out_of_range& e) {
91653       {
91654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91655       };
91656     } catch (std::exception& e) {
91657       {
91658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91659       };
91660     } catch (Dali::DaliException e) {
91661       {
91662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91663       };
91664     } catch (...) {
91665       {
91666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91667       };
91668     }
91669   }
91670
91671   jresult = result;
91672
91673   //argout typemap for const std::string&
91674
91675   return jresult;
91676 }
91677
91678
91679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91680   unsigned int jresult ;
91681   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91682   std::string *arg2 = 0 ;
91683   Dali::ImageDimensions arg3 ;
91684   Dali::ImageDimensions *argp3 ;
91685   uint32_t result;
91686
91687   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91688   if (!jarg2) {
91689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91690     return 0;
91691   }
91692   std::string arg2_str(jarg2);
91693   arg2 = &arg2_str;
91694   argp3 = (Dali::ImageDimensions *)jarg3;
91695   if (!argp3) {
91696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91697     return 0;
91698   }
91699   arg3 = *argp3;
91700   {
91701     try {
91702       result = (arg1)->Load((std::string const &)*arg2,arg3);
91703     } catch (std::out_of_range& e) {
91704       {
91705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91706       };
91707     } catch (std::exception& e) {
91708       {
91709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91710       };
91711     } catch (Dali::DaliException e) {
91712       {
91713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91714       };
91715     } catch (...) {
91716       {
91717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91718       };
91719     }
91720   }
91721
91722   jresult = result;
91723
91724   //argout typemap for const std::string&
91725
91726   return jresult;
91727 }
91728
91729
91730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91731   unsigned int jresult ;
91732   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91733   std::string *arg2 = 0 ;
91734   Dali::ImageDimensions arg3 ;
91735   Dali::FittingMode::Type arg4 ;
91736   Dali::SamplingMode::Type arg5 ;
91737   bool arg6 ;
91738   Dali::ImageDimensions *argp3 ;
91739   uint32_t result;
91740
91741   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91742   if (!jarg2) {
91743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91744     return 0;
91745   }
91746   std::string arg2_str(jarg2);
91747   arg2 = &arg2_str;
91748   argp3 = (Dali::ImageDimensions *)jarg3;
91749   if (!argp3) {
91750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91751     return 0;
91752   }
91753   arg3 = *argp3;
91754   arg4 = (Dali::FittingMode::Type)jarg4;
91755   arg5 = (Dali::SamplingMode::Type)jarg5;
91756   arg6 = jarg6 ? true : false;
91757   {
91758     try {
91759       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91760     } catch (std::out_of_range& e) {
91761       {
91762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91763       };
91764     } catch (std::exception& e) {
91765       {
91766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91767       };
91768     } catch (Dali::DaliException e) {
91769       {
91770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91771       };
91772     } catch (...) {
91773       {
91774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91775       };
91776     }
91777   }
91778
91779   jresult = result;
91780
91781   //argout typemap for const std::string&
91782
91783   return jresult;
91784 }
91785
91786
91787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91788   unsigned int jresult ;
91789   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91790   uint32_t arg2 ;
91791   bool result;
91792
91793   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91794   arg2 = (uint32_t)jarg2;
91795   {
91796     try {
91797       result = (bool)(arg1)->Cancel(arg2);
91798     } catch (std::out_of_range& e) {
91799       {
91800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91801       };
91802     } catch (std::exception& e) {
91803       {
91804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91805       };
91806     } catch (Dali::DaliException e) {
91807       {
91808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91809       };
91810     } catch (...) {
91811       {
91812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91813       };
91814     }
91815   }
91816
91817   jresult = result;
91818   return jresult;
91819 }
91820
91821
91822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91823   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91824
91825   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91826   {
91827     try {
91828       (arg1)->CancelAll();
91829     } catch (std::out_of_range& e) {
91830       {
91831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91832       };
91833     } catch (std::exception& e) {
91834       {
91835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91836       };
91837     } catch (Dali::DaliException e) {
91838       {
91839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91840       };
91841     } catch (...) {
91842       {
91843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91844       };
91845     }
91846   }
91847
91848 }
91849
91850
91851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91852   void * jresult ;
91853   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91854   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91855
91856   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91857   {
91858     try {
91859       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91860     } catch (std::out_of_range& e) {
91861       {
91862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91863       };
91864     } catch (std::exception& e) {
91865       {
91866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91867       };
91868     } catch (Dali::DaliException e) {
91869       {
91870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91871       };
91872     } catch (...) {
91873       {
91874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91875       };
91876     }
91877   }
91878
91879   jresult = (void *)result;
91880   return jresult;
91881 }
91882
91883
91884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91885   void * jresult ;
91886   std::string *arg1 = 0 ;
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   {
91896     try {
91897       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91898     } catch (std::out_of_range& e) {
91899       {
91900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91901       };
91902     } catch (std::exception& e) {
91903       {
91904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91905       };
91906     } catch (Dali::DaliException e) {
91907       {
91908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91909       };
91910     } catch (...) {
91911       {
91912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91913       };
91914     }
91915   }
91916
91917   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91918
91919   //argout typemap for const std::string&
91920
91921   return jresult;
91922 }
91923
91924
91925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91926   void * jresult ;
91927   std::string *arg1 = 0 ;
91928   Dali::ImageDimensions arg2 ;
91929   Dali::ImageDimensions *argp2 ;
91930   Dali::PixelData result;
91931
91932   if (!jarg1) {
91933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91934     return 0;
91935   }
91936   std::string arg1_str(jarg1);
91937   arg1 = &arg1_str;
91938   argp2 = (Dali::ImageDimensions *)jarg2;
91939   if (!argp2) {
91940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91941     return 0;
91942   }
91943   arg2 = *argp2;
91944   {
91945     try {
91946       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91947     } catch (std::out_of_range& e) {
91948       {
91949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91950       };
91951     } catch (std::exception& e) {
91952       {
91953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91954       };
91955     } catch (Dali::DaliException e) {
91956       {
91957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91958       };
91959     } catch (...) {
91960       {
91961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91962       };
91963     }
91964   }
91965
91966   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91967
91968   //argout typemap for const std::string&
91969
91970   return jresult;
91971 }
91972
91973
91974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91975   void * jresult ;
91976   std::string *arg1 = 0 ;
91977   Dali::ImageDimensions arg2 ;
91978   Dali::FittingMode::Type arg3 ;
91979   Dali::SamplingMode::Type arg4 ;
91980   bool arg5 ;
91981   Dali::ImageDimensions *argp2 ;
91982   Dali::PixelData result;
91983
91984   if (!jarg1) {
91985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91986     return 0;
91987   }
91988   std::string arg1_str(jarg1);
91989   arg1 = &arg1_str;
91990   argp2 = (Dali::ImageDimensions *)jarg2;
91991   if (!argp2) {
91992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91993     return 0;
91994   }
91995   arg2 = *argp2;
91996   arg3 = (Dali::FittingMode::Type)jarg3;
91997   arg4 = (Dali::SamplingMode::Type)jarg4;
91998   arg5 = jarg5 ? true : false;
91999   {
92000     try {
92001       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92002     } catch (std::out_of_range& e) {
92003       {
92004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92005       };
92006     } catch (std::exception& e) {
92007       {
92008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92009       };
92010     } catch (Dali::DaliException e) {
92011       {
92012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92013       };
92014     } catch (...) {
92015       {
92016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92017       };
92018     }
92019   }
92020
92021   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92022
92023   //argout typemap for const std::string&
92024
92025   return jresult;
92026 }
92027
92028
92029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92030   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92031
92032   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92033   {
92034     try {
92035       delete arg1;
92036     } catch (std::out_of_range& e) {
92037       {
92038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92039       };
92040     } catch (std::exception& e) {
92041       {
92042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92043       };
92044     } catch (Dali::DaliException e) {
92045       {
92046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92047       };
92048     } catch (...) {
92049       {
92050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92051       };
92052     }
92053   }
92054
92055 }
92056
92057
92058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92059   void * jresult ;
92060   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92061   Dali::Actor arg2 ;
92062   Dali::Actor arg3 ;
92063   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92064   Dali::Actor *argp2 ;
92065   Dali::Actor *argp3 ;
92066   Dali::Actor result;
92067
92068   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92069   argp2 = (Dali::Actor *)jarg2;
92070   if (!argp2) {
92071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92072     return 0;
92073   }
92074   arg2 = *argp2;
92075   argp3 = (Dali::Actor *)jarg3;
92076   if (!argp3) {
92077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92078     return 0;
92079   }
92080   arg3 = *argp3;
92081   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92082   {
92083     try {
92084       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92085     } catch (std::out_of_range& e) {
92086       {
92087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92088       };
92089     } catch (std::exception& e) {
92090       {
92091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92092       };
92093     } catch (Dali::DaliException e) {
92094       {
92095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92096       };
92097     } catch (...) {
92098       {
92099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92100       };
92101     }
92102   }
92103
92104   jresult = new Dali::Actor((const Dali::Actor &)result);
92105   return jresult;
92106 }
92107
92108
92109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92110   void * jresult ;
92111   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92112
92113   {
92114     try {
92115       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92116     } catch (std::out_of_range& e) {
92117       {
92118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92119       };
92120     } catch (std::exception& e) {
92121       {
92122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92123       };
92124     } catch (Dali::DaliException e) {
92125       {
92126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92127       };
92128     } catch (...) {
92129       {
92130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92131       };
92132     }
92133   }
92134
92135   jresult = (void *)result;
92136   return jresult;
92137 }
92138
92139
92140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92141   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92142   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92143   if (director) {
92144     director->swig_connect_director(callback0);
92145   }
92146 }
92147
92148
92149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92150   KeyboardFocusManager arg1 ;
92151   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92152   KeyboardFocusManager *argp1 ;
92153
92154   argp1 = (KeyboardFocusManager *)jarg1;
92155   if (!argp1) {
92156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92157     return ;
92158   }
92159   arg1 = *argp1;
92160   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92161   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
92162   {
92163     try {
92164       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92165     } catch (std::out_of_range& e) {
92166       {
92167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92168       };
92169     } catch (std::exception& e) {
92170       {
92171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92172       };
92173     } catch (Dali::DaliException e) {
92174       {
92175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92176       };
92177     } catch (...) {
92178       {
92179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92180       };
92181     }
92182   }
92183
92184 }
92185
92186
92187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92188   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92189
92190   arg1 = (std::vector< unsigned int > *)jarg1;
92191   {
92192     try {
92193       (arg1)->clear();
92194     } catch (std::out_of_range& e) {
92195       {
92196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92197       };
92198     } catch (std::exception& e) {
92199       {
92200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92201       };
92202     } catch (Dali::DaliException e) {
92203       {
92204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92205       };
92206     } catch (...) {
92207       {
92208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92209       };
92210     }
92211   }
92212
92213 }
92214
92215
92216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92217   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92218   unsigned int *arg2 = 0 ;
92219   unsigned int temp2 ;
92220
92221   arg1 = (std::vector< unsigned int > *)jarg1;
92222   temp2 = (unsigned int)jarg2;
92223   arg2 = &temp2;
92224   {
92225     try {
92226       (arg1)->push_back((unsigned int const &)*arg2);
92227     } catch (std::out_of_range& e) {
92228       {
92229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92230       };
92231     } catch (std::exception& e) {
92232       {
92233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92234       };
92235     } catch (Dali::DaliException e) {
92236       {
92237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92238       };
92239     } catch (...) {
92240       {
92241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92242       };
92243     }
92244   }
92245
92246 }
92247
92248
92249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92250   unsigned long jresult ;
92251   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92252   std::vector< unsigned int >::size_type result;
92253
92254   arg1 = (std::vector< unsigned int > *)jarg1;
92255   {
92256     try {
92257       result = ((std::vector< unsigned int > const *)arg1)->size();
92258     } catch (std::out_of_range& e) {
92259       {
92260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92261       };
92262     } catch (std::exception& e) {
92263       {
92264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92265       };
92266     } catch (Dali::DaliException e) {
92267       {
92268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92269       };
92270     } catch (...) {
92271       {
92272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92273       };
92274     }
92275   }
92276
92277   jresult = (unsigned long)result;
92278   return jresult;
92279 }
92280
92281
92282 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92283   unsigned long jresult ;
92284   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92285   std::vector< unsigned int >::size_type result;
92286
92287   arg1 = (std::vector< unsigned int > *)jarg1;
92288   {
92289     try {
92290       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92291     } catch (std::out_of_range& e) {
92292       {
92293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92294       };
92295     } catch (std::exception& e) {
92296       {
92297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92298       };
92299     } catch (Dali::DaliException e) {
92300       {
92301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92302       };
92303     } catch (...) {
92304       {
92305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92306       };
92307     }
92308   }
92309
92310   jresult = (unsigned long)result;
92311   return jresult;
92312 }
92313
92314
92315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92316   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92317   std::vector< unsigned int >::size_type arg2 ;
92318
92319   arg1 = (std::vector< unsigned int > *)jarg1;
92320   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92321   {
92322     try {
92323       (arg1)->reserve(arg2);
92324     } catch (std::out_of_range& e) {
92325       {
92326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92327       };
92328     } catch (std::exception& e) {
92329       {
92330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92331       };
92332     } catch (Dali::DaliException e) {
92333       {
92334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92335       };
92336     } catch (...) {
92337       {
92338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92339       };
92340     }
92341   }
92342
92343 }
92344
92345
92346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92347   void * jresult ;
92348   std::vector< unsigned int > *result = 0 ;
92349
92350   {
92351     try {
92352       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92353     } catch (std::out_of_range& e) {
92354       {
92355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92356       };
92357     } catch (std::exception& e) {
92358       {
92359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92360       };
92361     } catch (Dali::DaliException e) {
92362       {
92363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92364       };
92365     } catch (...) {
92366       {
92367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92368       };
92369     }
92370   }
92371
92372   jresult = (void *)result;
92373   return jresult;
92374 }
92375
92376
92377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92378   void * jresult ;
92379   std::vector< unsigned int > *arg1 = 0 ;
92380   std::vector< unsigned int > *result = 0 ;
92381
92382   arg1 = (std::vector< unsigned int > *)jarg1;
92383   if (!arg1) {
92384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92385     return 0;
92386   }
92387   {
92388     try {
92389       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92390     } catch (std::out_of_range& e) {
92391       {
92392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92393       };
92394     } catch (std::exception& e) {
92395       {
92396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92397       };
92398     } catch (Dali::DaliException e) {
92399       {
92400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92401       };
92402     } catch (...) {
92403       {
92404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92405       };
92406     }
92407   }
92408
92409   jresult = (void *)result;
92410   return jresult;
92411 }
92412
92413
92414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92415   void * jresult ;
92416   int arg1 ;
92417   std::vector< unsigned int > *result = 0 ;
92418
92419   arg1 = (int)jarg1;
92420   {
92421     try {
92422       try {
92423         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92424       }
92425       catch(std::out_of_range &_e) {
92426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92427         return 0;
92428       }
92429
92430     } catch (std::out_of_range& e) {
92431       {
92432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92433       };
92434     } catch (std::exception& e) {
92435       {
92436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92437       };
92438     } catch (Dali::DaliException e) {
92439       {
92440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92441       };
92442     } catch (...) {
92443       {
92444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92445       };
92446     }
92447   }
92448
92449   jresult = (void *)result;
92450   return jresult;
92451 }
92452
92453
92454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92455   unsigned int jresult ;
92456   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92457   int arg2 ;
92458   unsigned int result;
92459
92460   arg1 = (std::vector< unsigned int > *)jarg1;
92461   arg2 = (int)jarg2;
92462   {
92463     try {
92464       try {
92465         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92466       }
92467       catch(std::out_of_range &_e) {
92468         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92469         return 0;
92470       }
92471
92472     } catch (std::out_of_range& e) {
92473       {
92474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92475       };
92476     } catch (std::exception& e) {
92477       {
92478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92479       };
92480     } catch (Dali::DaliException e) {
92481       {
92482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92483       };
92484     } catch (...) {
92485       {
92486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92487       };
92488     }
92489   }
92490
92491   jresult = result;
92492   return jresult;
92493 }
92494
92495
92496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92497   unsigned int jresult ;
92498   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92499   int arg2 ;
92500   unsigned int *result = 0 ;
92501
92502   arg1 = (std::vector< unsigned int > *)jarg1;
92503   arg2 = (int)jarg2;
92504   {
92505     try {
92506       try {
92507         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92508       }
92509       catch(std::out_of_range &_e) {
92510         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92511         return 0;
92512       }
92513
92514     } catch (std::out_of_range& e) {
92515       {
92516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92517       };
92518     } catch (std::exception& e) {
92519       {
92520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92521       };
92522     } catch (Dali::DaliException e) {
92523       {
92524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92525       };
92526     } catch (...) {
92527       {
92528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92529       };
92530     }
92531   }
92532
92533   jresult = *result;
92534   return jresult;
92535 }
92536
92537
92538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92539   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92540   int arg2 ;
92541   unsigned int *arg3 = 0 ;
92542   unsigned int temp3 ;
92543
92544   arg1 = (std::vector< unsigned int > *)jarg1;
92545   arg2 = (int)jarg2;
92546   temp3 = (unsigned int)jarg3;
92547   arg3 = &temp3;
92548   {
92549     try {
92550       try {
92551         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92552       }
92553       catch(std::out_of_range &_e) {
92554         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92555         return ;
92556       }
92557
92558     } catch (std::out_of_range& e) {
92559       {
92560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92561       };
92562     } catch (std::exception& e) {
92563       {
92564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92565       };
92566     } catch (Dali::DaliException e) {
92567       {
92568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92569       };
92570     } catch (...) {
92571       {
92572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92573       };
92574     }
92575   }
92576
92577 }
92578
92579
92580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92581   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92582   std::vector< unsigned int > *arg2 = 0 ;
92583
92584   arg1 = (std::vector< unsigned int > *)jarg1;
92585   arg2 = (std::vector< unsigned int > *)jarg2;
92586   if (!arg2) {
92587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92588     return ;
92589   }
92590   {
92591     try {
92592       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92593     } catch (std::out_of_range& e) {
92594       {
92595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92596       };
92597     } catch (std::exception& e) {
92598       {
92599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92600       };
92601     } catch (Dali::DaliException e) {
92602       {
92603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92604       };
92605     } catch (...) {
92606       {
92607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92608       };
92609     }
92610   }
92611
92612 }
92613
92614
92615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92616   void * jresult ;
92617   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92618   int arg2 ;
92619   int arg3 ;
92620   std::vector< unsigned int > *result = 0 ;
92621
92622   arg1 = (std::vector< unsigned int > *)jarg1;
92623   arg2 = (int)jarg2;
92624   arg3 = (int)jarg3;
92625   {
92626     try {
92627       try {
92628         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92629       }
92630       catch(std::out_of_range &_e) {
92631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92632         return 0;
92633       }
92634       catch(std::invalid_argument &_e) {
92635         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92636         return 0;
92637       }
92638
92639     } catch (std::out_of_range& e) {
92640       {
92641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92642       };
92643     } catch (std::exception& e) {
92644       {
92645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92646       };
92647     } catch (Dali::DaliException e) {
92648       {
92649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92650       };
92651     } catch (...) {
92652       {
92653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92654       };
92655     }
92656   }
92657
92658   jresult = (void *)result;
92659   return jresult;
92660 }
92661
92662
92663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92664   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92665   int arg2 ;
92666   unsigned int *arg3 = 0 ;
92667   unsigned int temp3 ;
92668
92669   arg1 = (std::vector< unsigned int > *)jarg1;
92670   arg2 = (int)jarg2;
92671   temp3 = (unsigned int)jarg3;
92672   arg3 = &temp3;
92673   {
92674     try {
92675       try {
92676         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92677       }
92678       catch(std::out_of_range &_e) {
92679         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92680         return ;
92681       }
92682
92683     } catch (std::out_of_range& e) {
92684       {
92685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92686       };
92687     } catch (std::exception& e) {
92688       {
92689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92690       };
92691     } catch (Dali::DaliException e) {
92692       {
92693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92694       };
92695     } catch (...) {
92696       {
92697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92698       };
92699     }
92700   }
92701
92702 }
92703
92704
92705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92706   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92707   int arg2 ;
92708   std::vector< unsigned int > *arg3 = 0 ;
92709
92710   arg1 = (std::vector< unsigned int > *)jarg1;
92711   arg2 = (int)jarg2;
92712   arg3 = (std::vector< unsigned int > *)jarg3;
92713   if (!arg3) {
92714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92715     return ;
92716   }
92717   {
92718     try {
92719       try {
92720         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92721       }
92722       catch(std::out_of_range &_e) {
92723         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92724         return ;
92725       }
92726
92727     } catch (std::out_of_range& e) {
92728       {
92729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92730       };
92731     } catch (std::exception& e) {
92732       {
92733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92734       };
92735     } catch (Dali::DaliException e) {
92736       {
92737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92738       };
92739     } catch (...) {
92740       {
92741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92742       };
92743     }
92744   }
92745
92746 }
92747
92748
92749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92750   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92751   int arg2 ;
92752
92753   arg1 = (std::vector< unsigned int > *)jarg1;
92754   arg2 = (int)jarg2;
92755   {
92756     try {
92757       try {
92758         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92759       }
92760       catch(std::out_of_range &_e) {
92761         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92762         return ;
92763       }
92764
92765     } catch (std::out_of_range& e) {
92766       {
92767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92768       };
92769     } catch (std::exception& e) {
92770       {
92771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92772       };
92773     } catch (Dali::DaliException e) {
92774       {
92775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92776       };
92777     } catch (...) {
92778       {
92779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92780       };
92781     }
92782   }
92783
92784 }
92785
92786
92787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92788   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92789   int arg2 ;
92790   int arg3 ;
92791
92792   arg1 = (std::vector< unsigned int > *)jarg1;
92793   arg2 = (int)jarg2;
92794   arg3 = (int)jarg3;
92795   {
92796     try {
92797       try {
92798         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92799       }
92800       catch(std::out_of_range &_e) {
92801         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92802         return ;
92803       }
92804       catch(std::invalid_argument &_e) {
92805         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92806         return ;
92807       }
92808
92809     } catch (std::out_of_range& e) {
92810       {
92811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92812       };
92813     } catch (std::exception& e) {
92814       {
92815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92816       };
92817     } catch (Dali::DaliException e) {
92818       {
92819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92820       };
92821     } catch (...) {
92822       {
92823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92824       };
92825     }
92826   }
92827
92828 }
92829
92830
92831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92832   void * jresult ;
92833   unsigned int *arg1 = 0 ;
92834   int arg2 ;
92835   unsigned int temp1 ;
92836   std::vector< unsigned int > *result = 0 ;
92837
92838   temp1 = (unsigned int)jarg1;
92839   arg1 = &temp1;
92840   arg2 = (int)jarg2;
92841   {
92842     try {
92843       try {
92844         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92845       }
92846       catch(std::out_of_range &_e) {
92847         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92848         return 0;
92849       }
92850
92851     } catch (std::out_of_range& e) {
92852       {
92853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92854       };
92855     } catch (std::exception& e) {
92856       {
92857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92858       };
92859     } catch (Dali::DaliException e) {
92860       {
92861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92862       };
92863     } catch (...) {
92864       {
92865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92866       };
92867     }
92868   }
92869
92870   jresult = (void *)result;
92871   return jresult;
92872 }
92873
92874
92875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92876   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92877
92878   arg1 = (std::vector< unsigned int > *)jarg1;
92879   {
92880     try {
92881       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92882     } catch (std::out_of_range& e) {
92883       {
92884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92885       };
92886     } catch (std::exception& e) {
92887       {
92888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92889       };
92890     } catch (Dali::DaliException e) {
92891       {
92892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92893       };
92894     } catch (...) {
92895       {
92896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92897       };
92898     }
92899   }
92900
92901 }
92902
92903
92904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92905   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92906   int arg2 ;
92907   int arg3 ;
92908
92909   arg1 = (std::vector< unsigned int > *)jarg1;
92910   arg2 = (int)jarg2;
92911   arg3 = (int)jarg3;
92912   {
92913     try {
92914       try {
92915         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92916       }
92917       catch(std::out_of_range &_e) {
92918         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92919         return ;
92920       }
92921       catch(std::invalid_argument &_e) {
92922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92923         return ;
92924       }
92925
92926     } catch (std::out_of_range& e) {
92927       {
92928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92929       };
92930     } catch (std::exception& e) {
92931       {
92932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92933       };
92934     } catch (Dali::DaliException e) {
92935       {
92936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92937       };
92938     } catch (...) {
92939       {
92940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92941       };
92942     }
92943   }
92944
92945 }
92946
92947
92948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92949   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92950   int arg2 ;
92951   std::vector< unsigned int > *arg3 = 0 ;
92952
92953   arg1 = (std::vector< unsigned int > *)jarg1;
92954   arg2 = (int)jarg2;
92955   arg3 = (std::vector< unsigned int > *)jarg3;
92956   if (!arg3) {
92957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92958     return ;
92959   }
92960   {
92961     try {
92962       try {
92963         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92964       }
92965       catch(std::out_of_range &_e) {
92966         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92967         return ;
92968       }
92969
92970     } catch (std::out_of_range& e) {
92971       {
92972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92973       };
92974     } catch (std::exception& e) {
92975       {
92976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92977       };
92978     } catch (Dali::DaliException e) {
92979       {
92980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92981       };
92982     } catch (...) {
92983       {
92984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92985       };
92986     }
92987   }
92988
92989 }
92990
92991
92992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92993   unsigned int jresult ;
92994   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92995   unsigned int *arg2 = 0 ;
92996   unsigned int temp2 ;
92997   bool result;
92998
92999   arg1 = (std::vector< unsigned int > *)jarg1;
93000   temp2 = (unsigned int)jarg2;
93001   arg2 = &temp2;
93002   {
93003     try {
93004       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93005     } catch (std::out_of_range& e) {
93006       {
93007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93008       };
93009     } catch (std::exception& e) {
93010       {
93011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93012       };
93013     } catch (Dali::DaliException e) {
93014       {
93015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93016       };
93017     } catch (...) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93020       };
93021     }
93022   }
93023
93024   jresult = result;
93025   return jresult;
93026 }
93027
93028
93029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93030   int jresult ;
93031   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93032   unsigned int *arg2 = 0 ;
93033   unsigned int temp2 ;
93034   int result;
93035
93036   arg1 = (std::vector< unsigned int > *)jarg1;
93037   temp2 = (unsigned int)jarg2;
93038   arg2 = &temp2;
93039   {
93040     try {
93041       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93042     } catch (std::out_of_range& e) {
93043       {
93044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93045       };
93046     } catch (std::exception& e) {
93047       {
93048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93049       };
93050     } catch (Dali::DaliException e) {
93051       {
93052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93053       };
93054     } catch (...) {
93055       {
93056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93057       };
93058     }
93059   }
93060
93061   jresult = result;
93062   return jresult;
93063 }
93064
93065
93066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93067   int jresult ;
93068   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93069   unsigned int *arg2 = 0 ;
93070   unsigned int temp2 ;
93071   int result;
93072
93073   arg1 = (std::vector< unsigned int > *)jarg1;
93074   temp2 = (unsigned int)jarg2;
93075   arg2 = &temp2;
93076   {
93077     try {
93078       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93079     } catch (std::out_of_range& e) {
93080       {
93081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93082       };
93083     } catch (std::exception& e) {
93084       {
93085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93086       };
93087     } catch (Dali::DaliException e) {
93088       {
93089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93090       };
93091     } catch (...) {
93092       {
93093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93094       };
93095     }
93096   }
93097
93098   jresult = result;
93099   return jresult;
93100 }
93101
93102
93103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93104   unsigned int jresult ;
93105   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93106   unsigned int *arg2 = 0 ;
93107   unsigned int temp2 ;
93108   bool result;
93109
93110   arg1 = (std::vector< unsigned int > *)jarg1;
93111   temp2 = (unsigned int)jarg2;
93112   arg2 = &temp2;
93113   {
93114     try {
93115       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93116     } catch (std::out_of_range& e) {
93117       {
93118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93119       };
93120     } catch (std::exception& e) {
93121       {
93122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93123       };
93124     } catch (Dali::DaliException e) {
93125       {
93126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93127       };
93128     } catch (...) {
93129       {
93130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93131       };
93132     }
93133   }
93134
93135   jresult = result;
93136   return jresult;
93137 }
93138
93139
93140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93141   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93142
93143   arg1 = (std::vector< unsigned int > *)jarg1;
93144   {
93145     try {
93146       delete arg1;
93147     } catch (std::out_of_range& e) {
93148       {
93149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93150       };
93151     } catch (std::exception& e) {
93152       {
93153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93154       };
93155     } catch (Dali::DaliException e) {
93156       {
93157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93158       };
93159     } catch (...) {
93160       {
93161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93162       };
93163     }
93164   }
93165
93166 }
93167
93168
93169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93170   void * jresult ;
93171   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93172
93173   {
93174     try {
93175       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93176     } catch (std::out_of_range& e) {
93177       {
93178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93179       };
93180     } catch (std::exception& e) {
93181       {
93182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93183       };
93184     } catch (Dali::DaliException e) {
93185       {
93186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93187       };
93188     } catch (...) {
93189       {
93190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93191       };
93192     }
93193   }
93194
93195   jresult = (void *)result;
93196   return jresult;
93197 }
93198
93199
93200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93201   void * jresult ;
93202   unsigned int arg1 ;
93203   Dali::Actor arg2 ;
93204   Dali::Actor *argp2 ;
93205   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93206
93207   arg1 = (unsigned int)jarg1;
93208   argp2 = (Dali::Actor *)jarg2;
93209   if (!argp2) {
93210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93211     return 0;
93212   }
93213   arg2 = *argp2;
93214   {
93215     try {
93216       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93217     } catch (std::out_of_range& e) {
93218       {
93219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93220       };
93221     } catch (std::exception& e) {
93222       {
93223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93224       };
93225     } catch (Dali::DaliException e) {
93226       {
93227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93228       };
93229     } catch (...) {
93230       {
93231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93232       };
93233     }
93234   }
93235
93236   jresult = (void *)result;
93237   return jresult;
93238 }
93239
93240
93241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93242   void * jresult ;
93243   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93244   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93245
93246   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93247   if (!arg1) {
93248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93249     return 0;
93250   }
93251   {
93252     try {
93253       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93254     } catch (std::out_of_range& e) {
93255       {
93256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93257       };
93258     } catch (std::exception& e) {
93259       {
93260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93261       };
93262     } catch (Dali::DaliException e) {
93263       {
93264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93265       };
93266     } catch (...) {
93267       {
93268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93269       };
93270     }
93271   }
93272
93273   jresult = (void *)result;
93274   return jresult;
93275 }
93276
93277
93278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93279   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93280   unsigned int arg2 ;
93281
93282   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93283   arg2 = (unsigned int)jarg2;
93284   if (arg1) (arg1)->first = arg2;
93285 }
93286
93287
93288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93289   unsigned int jresult ;
93290   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93291   unsigned int result;
93292
93293   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93294   result = (unsigned int) ((arg1)->first);
93295   jresult = result;
93296   return jresult;
93297 }
93298
93299
93300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93301   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93302   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93303
93304   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93305   arg2 = (Dali::Actor *)jarg2;
93306   if (arg1) (arg1)->second = *arg2;
93307 }
93308
93309
93310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93311   void * jresult ;
93312   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93313   Dali::Actor *result = 0 ;
93314
93315   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93316   result = (Dali::Actor *)& ((arg1)->second);
93317   jresult = (void *)result;
93318   return jresult;
93319 }
93320
93321
93322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93323   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93324
93325   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93326   {
93327     try {
93328       delete arg1;
93329     } catch (std::out_of_range& e) {
93330       {
93331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93332       };
93333     } catch (std::exception& e) {
93334       {
93335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93336       };
93337     } catch (Dali::DaliException e) {
93338       {
93339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93340       };
93341     } catch (...) {
93342       {
93343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93344       };
93345     }
93346   }
93347
93348 }
93349
93350
93351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93352   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93353
93354   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93355   {
93356     try {
93357       (arg1)->clear();
93358     } catch (std::out_of_range& e) {
93359       {
93360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93361       };
93362     } catch (std::exception& e) {
93363       {
93364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93365       };
93366     } catch (Dali::DaliException e) {
93367       {
93368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93369       };
93370     } catch (...) {
93371       {
93372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93373       };
93374     }
93375   }
93376
93377 }
93378
93379
93380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93381   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93382   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93383
93384   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93385   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93386   if (!arg2) {
93387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93388     return ;
93389   }
93390   {
93391     try {
93392       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93393     } catch (std::out_of_range& e) {
93394       {
93395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93396       };
93397     } catch (std::exception& e) {
93398       {
93399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93400       };
93401     } catch (Dali::DaliException e) {
93402       {
93403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93404       };
93405     } catch (...) {
93406       {
93407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93408       };
93409     }
93410   }
93411
93412 }
93413
93414
93415 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93416   unsigned long jresult ;
93417   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93418   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93419
93420   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93421   {
93422     try {
93423       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93424     } catch (std::out_of_range& e) {
93425       {
93426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93427       };
93428     } catch (std::exception& e) {
93429       {
93430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93431       };
93432     } catch (Dali::DaliException e) {
93433       {
93434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93435       };
93436     } catch (...) {
93437       {
93438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93439       };
93440     }
93441   }
93442
93443   jresult = (unsigned long)result;
93444   return jresult;
93445 }
93446
93447
93448 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93449   unsigned long jresult ;
93450   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93451   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93452
93453   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93454   {
93455     try {
93456       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93457     } catch (std::out_of_range& e) {
93458       {
93459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93460       };
93461     } catch (std::exception& e) {
93462       {
93463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93464       };
93465     } catch (Dali::DaliException e) {
93466       {
93467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93468       };
93469     } catch (...) {
93470       {
93471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93472       };
93473     }
93474   }
93475
93476   jresult = (unsigned long)result;
93477   return jresult;
93478 }
93479
93480
93481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93482   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93483   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93484
93485   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93486   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93487   {
93488     try {
93489       (arg1)->reserve(arg2);
93490     } catch (std::out_of_range& e) {
93491       {
93492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93493       };
93494     } catch (std::exception& e) {
93495       {
93496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93497       };
93498     } catch (Dali::DaliException e) {
93499       {
93500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93501       };
93502     } catch (...) {
93503       {
93504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93505       };
93506     }
93507   }
93508
93509 }
93510
93511
93512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93513   void * jresult ;
93514   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93515
93516   {
93517     try {
93518       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93519     } catch (std::out_of_range& e) {
93520       {
93521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93522       };
93523     } catch (std::exception& e) {
93524       {
93525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93526       };
93527     } catch (Dali::DaliException e) {
93528       {
93529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93530       };
93531     } catch (...) {
93532       {
93533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93534       };
93535     }
93536   }
93537
93538   jresult = (void *)result;
93539   return jresult;
93540 }
93541
93542
93543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93544   void * jresult ;
93545   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93546   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93547
93548   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93549   if (!arg1) {
93550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93551     return 0;
93552   }
93553   {
93554     try {
93555       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);
93556     } catch (std::out_of_range& e) {
93557       {
93558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93559       };
93560     } catch (std::exception& e) {
93561       {
93562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93563       };
93564     } catch (Dali::DaliException e) {
93565       {
93566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93567       };
93568     } catch (...) {
93569       {
93570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93571       };
93572     }
93573   }
93574
93575   jresult = (void *)result;
93576   return jresult;
93577 }
93578
93579
93580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93581   void * jresult ;
93582   int arg1 ;
93583   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93584
93585   arg1 = (int)jarg1;
93586   {
93587     try {
93588       try {
93589         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);
93590       }
93591       catch(std::out_of_range &_e) {
93592         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93593         return 0;
93594       }
93595
93596     } catch (std::out_of_range& e) {
93597       {
93598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93599       };
93600     } catch (std::exception& e) {
93601       {
93602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93603       };
93604     } catch (Dali::DaliException e) {
93605       {
93606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93607       };
93608     } catch (...) {
93609       {
93610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93611       };
93612     }
93613   }
93614
93615   jresult = (void *)result;
93616   return jresult;
93617 }
93618
93619
93620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93621   void * jresult ;
93622   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93623   int arg2 ;
93624   std::pair< unsigned int,Dali::Actor > result;
93625
93626   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93627   arg2 = (int)jarg2;
93628   {
93629     try {
93630       try {
93631         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93632       }
93633       catch(std::out_of_range &_e) {
93634         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93635         return 0;
93636       }
93637
93638     } catch (std::out_of_range& e) {
93639       {
93640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93641       };
93642     } catch (std::exception& e) {
93643       {
93644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93645       };
93646     } catch (Dali::DaliException e) {
93647       {
93648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93649       };
93650     } catch (...) {
93651       {
93652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93653       };
93654     }
93655   }
93656
93657   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93658   return jresult;
93659 }
93660
93661
93662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93663   void * jresult ;
93664   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93665   int arg2 ;
93666   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93667
93668   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93669   arg2 = (int)jarg2;
93670   {
93671     try {
93672       try {
93673         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93674       }
93675       catch(std::out_of_range &_e) {
93676         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93677         return 0;
93678       }
93679
93680     } catch (std::out_of_range& e) {
93681       {
93682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93683       };
93684     } catch (std::exception& e) {
93685       {
93686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93687       };
93688     } catch (Dali::DaliException e) {
93689       {
93690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93691       };
93692     } catch (...) {
93693       {
93694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93695       };
93696     }
93697   }
93698
93699   jresult = (void *)result;
93700   return jresult;
93701 }
93702
93703
93704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93705   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93706   int arg2 ;
93707   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93708
93709   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93710   arg2 = (int)jarg2;
93711   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93712   if (!arg3) {
93713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93714     return ;
93715   }
93716   {
93717     try {
93718       try {
93719         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);
93720       }
93721       catch(std::out_of_range &_e) {
93722         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93723         return ;
93724       }
93725
93726     } catch (std::out_of_range& e) {
93727       {
93728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93729       };
93730     } catch (std::exception& e) {
93731       {
93732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93733       };
93734     } catch (Dali::DaliException e) {
93735       {
93736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93737       };
93738     } catch (...) {
93739       {
93740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93741       };
93742     }
93743   }
93744
93745 }
93746
93747
93748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93749   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93750   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93751
93752   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93753   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93754   if (!arg2) {
93755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93756     return ;
93757   }
93758   {
93759     try {
93760       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);
93761     } catch (std::out_of_range& e) {
93762       {
93763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93764       };
93765     } catch (std::exception& e) {
93766       {
93767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93768       };
93769     } catch (Dali::DaliException e) {
93770       {
93771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93772       };
93773     } catch (...) {
93774       {
93775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93776       };
93777     }
93778   }
93779
93780 }
93781
93782
93783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93784   void * jresult ;
93785   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93786   int arg2 ;
93787   int arg3 ;
93788   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93789
93790   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93791   arg2 = (int)jarg2;
93792   arg3 = (int)jarg3;
93793   {
93794     try {
93795       try {
93796         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);
93797       }
93798       catch(std::out_of_range &_e) {
93799         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93800         return 0;
93801       }
93802       catch(std::invalid_argument &_e) {
93803         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93804         return 0;
93805       }
93806
93807     } catch (std::out_of_range& e) {
93808       {
93809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93810       };
93811     } catch (std::exception& e) {
93812       {
93813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93814       };
93815     } catch (Dali::DaliException e) {
93816       {
93817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93818       };
93819     } catch (...) {
93820       {
93821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93822       };
93823     }
93824   }
93825
93826   jresult = (void *)result;
93827   return jresult;
93828 }
93829
93830
93831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93832   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93833   int arg2 ;
93834   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93835
93836   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93837   arg2 = (int)jarg2;
93838   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93839   if (!arg3) {
93840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93841     return ;
93842   }
93843   {
93844     try {
93845       try {
93846         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);
93847       }
93848       catch(std::out_of_range &_e) {
93849         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93850         return ;
93851       }
93852
93853     } catch (std::out_of_range& e) {
93854       {
93855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93856       };
93857     } catch (std::exception& e) {
93858       {
93859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93860       };
93861     } catch (Dali::DaliException e) {
93862       {
93863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93864       };
93865     } catch (...) {
93866       {
93867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93868       };
93869     }
93870   }
93871
93872 }
93873
93874
93875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93876   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93877   int arg2 ;
93878   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93879
93880   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93881   arg2 = (int)jarg2;
93882   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93883   if (!arg3) {
93884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93885     return ;
93886   }
93887   {
93888     try {
93889       try {
93890         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);
93891       }
93892       catch(std::out_of_range &_e) {
93893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93894         return ;
93895       }
93896
93897     } catch (std::out_of_range& e) {
93898       {
93899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93900       };
93901     } catch (std::exception& e) {
93902       {
93903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93904       };
93905     } catch (Dali::DaliException e) {
93906       {
93907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93908       };
93909     } catch (...) {
93910       {
93911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93912       };
93913     }
93914   }
93915
93916 }
93917
93918
93919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93920   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93921   int arg2 ;
93922
93923   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93924   arg2 = (int)jarg2;
93925   {
93926     try {
93927       try {
93928         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93929       }
93930       catch(std::out_of_range &_e) {
93931         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93932         return ;
93933       }
93934
93935     } catch (std::out_of_range& e) {
93936       {
93937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93938       };
93939     } catch (std::exception& e) {
93940       {
93941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93942       };
93943     } catch (Dali::DaliException e) {
93944       {
93945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93946       };
93947     } catch (...) {
93948       {
93949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93950       };
93951     }
93952   }
93953
93954 }
93955
93956
93957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93958   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93959   int arg2 ;
93960   int arg3 ;
93961
93962   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93963   arg2 = (int)jarg2;
93964   arg3 = (int)jarg3;
93965   {
93966     try {
93967       try {
93968         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93969       }
93970       catch(std::out_of_range &_e) {
93971         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93972         return ;
93973       }
93974       catch(std::invalid_argument &_e) {
93975         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93976         return ;
93977       }
93978
93979     } catch (std::out_of_range& e) {
93980       {
93981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93982       };
93983     } catch (std::exception& e) {
93984       {
93985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93986       };
93987     } catch (Dali::DaliException e) {
93988       {
93989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93990       };
93991     } catch (...) {
93992       {
93993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93994       };
93995     }
93996   }
93997
93998 }
93999
94000
94001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94002   void * jresult ;
94003   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94004   int arg2 ;
94005   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94006
94007   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94008   if (!arg1) {
94009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94010     return 0;
94011   }
94012   arg2 = (int)jarg2;
94013   {
94014     try {
94015       try {
94016         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);
94017       }
94018       catch(std::out_of_range &_e) {
94019         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94020         return 0;
94021       }
94022
94023     } catch (std::out_of_range& e) {
94024       {
94025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94026       };
94027     } catch (std::exception& e) {
94028       {
94029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94030       };
94031     } catch (Dali::DaliException e) {
94032       {
94033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94034       };
94035     } catch (...) {
94036       {
94037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94038       };
94039     }
94040   }
94041
94042   jresult = (void *)result;
94043   return jresult;
94044 }
94045
94046
94047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94048   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94049
94050   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94051   {
94052     try {
94053       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94054     } catch (std::out_of_range& e) {
94055       {
94056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94057       };
94058     } catch (std::exception& e) {
94059       {
94060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94061       };
94062     } catch (Dali::DaliException e) {
94063       {
94064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94065       };
94066     } catch (...) {
94067       {
94068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94069       };
94070     }
94071   }
94072
94073 }
94074
94075
94076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94077   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94078   int arg2 ;
94079   int arg3 ;
94080
94081   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94082   arg2 = (int)jarg2;
94083   arg3 = (int)jarg3;
94084   {
94085     try {
94086       try {
94087         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94088       }
94089       catch(std::out_of_range &_e) {
94090         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94091         return ;
94092       }
94093       catch(std::invalid_argument &_e) {
94094         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94095         return ;
94096       }
94097
94098     } catch (std::out_of_range& e) {
94099       {
94100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94101       };
94102     } catch (std::exception& e) {
94103       {
94104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94105       };
94106     } catch (Dali::DaliException e) {
94107       {
94108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94109       };
94110     } catch (...) {
94111       {
94112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94113       };
94114     }
94115   }
94116
94117 }
94118
94119
94120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94121   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94122   int arg2 ;
94123   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94124
94125   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94126   arg2 = (int)jarg2;
94127   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94128   if (!arg3) {
94129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94130     return ;
94131   }
94132   {
94133     try {
94134       try {
94135         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);
94136       }
94137       catch(std::out_of_range &_e) {
94138         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94139         return ;
94140       }
94141
94142     } catch (std::out_of_range& e) {
94143       {
94144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94145       };
94146     } catch (std::exception& e) {
94147       {
94148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94149       };
94150     } catch (Dali::DaliException e) {
94151       {
94152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94153       };
94154     } catch (...) {
94155       {
94156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94157       };
94158     }
94159   }
94160
94161 }
94162
94163
94164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94165   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94166
94167   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94168   {
94169     try {
94170       delete arg1;
94171     } catch (std::out_of_range& e) {
94172       {
94173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94174       };
94175     } catch (std::exception& e) {
94176       {
94177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94178       };
94179     } catch (Dali::DaliException e) {
94180       {
94181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94182       };
94183     } catch (...) {
94184       {
94185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94186       };
94187     }
94188   }
94189
94190 }
94191
94192
94193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94194   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94195
94196   arg1 = (std::vector< Dali::Actor > *)jarg1;
94197   {
94198     try {
94199       (arg1)->clear();
94200     } catch (std::out_of_range& e) {
94201       {
94202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94203       };
94204     } catch (std::exception& e) {
94205       {
94206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94207       };
94208     } catch (Dali::DaliException e) {
94209       {
94210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94211       };
94212     } catch (...) {
94213       {
94214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94215       };
94216     }
94217   }
94218
94219 }
94220
94221
94222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94223   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94224   Dali::Actor *arg2 = 0 ;
94225
94226   arg1 = (std::vector< Dali::Actor > *)jarg1;
94227   arg2 = (Dali::Actor *)jarg2;
94228   if (!arg2) {
94229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94230     return ;
94231   }
94232   {
94233     try {
94234       (arg1)->push_back((Dali::Actor const &)*arg2);
94235     } catch (std::out_of_range& e) {
94236       {
94237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94238       };
94239     } catch (std::exception& e) {
94240       {
94241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94242       };
94243     } catch (Dali::DaliException e) {
94244       {
94245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94246       };
94247     } catch (...) {
94248       {
94249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94250       };
94251     }
94252   }
94253
94254 }
94255
94256
94257 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94258   unsigned long jresult ;
94259   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94260   std::vector< Dali::Actor >::size_type result;
94261
94262   arg1 = (std::vector< Dali::Actor > *)jarg1;
94263   {
94264     try {
94265       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94266     } catch (std::out_of_range& e) {
94267       {
94268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94269       };
94270     } catch (std::exception& e) {
94271       {
94272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94273       };
94274     } catch (Dali::DaliException e) {
94275       {
94276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94277       };
94278     } catch (...) {
94279       {
94280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94281       };
94282     }
94283   }
94284
94285   jresult = (unsigned long)result;
94286   return jresult;
94287 }
94288
94289
94290 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94291   unsigned long jresult ;
94292   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94293   std::vector< Dali::Actor >::size_type result;
94294
94295   arg1 = (std::vector< Dali::Actor > *)jarg1;
94296   {
94297     try {
94298       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94299     } catch (std::out_of_range& e) {
94300       {
94301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94302       };
94303     } catch (std::exception& e) {
94304       {
94305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94306       };
94307     } catch (Dali::DaliException e) {
94308       {
94309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94310       };
94311     } catch (...) {
94312       {
94313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94314       };
94315     }
94316   }
94317
94318   jresult = (unsigned long)result;
94319   return jresult;
94320 }
94321
94322
94323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94324   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94325   std::vector< Dali::Actor >::size_type arg2 ;
94326
94327   arg1 = (std::vector< Dali::Actor > *)jarg1;
94328   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94329   {
94330     try {
94331       (arg1)->reserve(arg2);
94332     } catch (std::out_of_range& e) {
94333       {
94334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94335       };
94336     } catch (std::exception& e) {
94337       {
94338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94339       };
94340     } catch (Dali::DaliException e) {
94341       {
94342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94343       };
94344     } catch (...) {
94345       {
94346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94347       };
94348     }
94349   }
94350
94351 }
94352
94353
94354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94355   void * jresult ;
94356   std::vector< Dali::Actor > *result = 0 ;
94357
94358   {
94359     try {
94360       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94361     } catch (std::out_of_range& e) {
94362       {
94363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94364       };
94365     } catch (std::exception& e) {
94366       {
94367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94368       };
94369     } catch (Dali::DaliException e) {
94370       {
94371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94372       };
94373     } catch (...) {
94374       {
94375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94376       };
94377     }
94378   }
94379
94380   jresult = (void *)result;
94381   return jresult;
94382 }
94383
94384
94385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94386   void * jresult ;
94387   std::vector< Dali::Actor > *arg1 = 0 ;
94388   std::vector< Dali::Actor > *result = 0 ;
94389
94390   arg1 = (std::vector< Dali::Actor > *)jarg1;
94391   if (!arg1) {
94392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94393     return 0;
94394   }
94395   {
94396     try {
94397       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94398     } catch (std::out_of_range& e) {
94399       {
94400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94401       };
94402     } catch (std::exception& e) {
94403       {
94404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94405       };
94406     } catch (Dali::DaliException e) {
94407       {
94408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94409       };
94410     } catch (...) {
94411       {
94412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94413       };
94414     }
94415   }
94416
94417   jresult = (void *)result;
94418   return jresult;
94419 }
94420
94421
94422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94423   void * jresult ;
94424   int arg1 ;
94425   std::vector< Dali::Actor > *result = 0 ;
94426
94427   arg1 = (int)jarg1;
94428   {
94429     try {
94430       try {
94431         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94432       }
94433       catch(std::out_of_range &_e) {
94434         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94435         return 0;
94436       }
94437
94438     } catch (std::out_of_range& e) {
94439       {
94440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94441       };
94442     } catch (std::exception& e) {
94443       {
94444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94445       };
94446     } catch (Dali::DaliException e) {
94447       {
94448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94449       };
94450     } catch (...) {
94451       {
94452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94453       };
94454     }
94455   }
94456
94457   jresult = (void *)result;
94458   return jresult;
94459 }
94460
94461
94462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94463   void * jresult ;
94464   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94465   int arg2 ;
94466   Dali::Actor result;
94467
94468   arg1 = (std::vector< Dali::Actor > *)jarg1;
94469   arg2 = (int)jarg2;
94470   {
94471     try {
94472       try {
94473         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94474       }
94475       catch(std::out_of_range &_e) {
94476         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94477         return 0;
94478       }
94479
94480     } catch (std::out_of_range& e) {
94481       {
94482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94483       };
94484     } catch (std::exception& e) {
94485       {
94486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94487       };
94488     } catch (Dali::DaliException e) {
94489       {
94490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94491       };
94492     } catch (...) {
94493       {
94494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94495       };
94496     }
94497   }
94498
94499   jresult = new Dali::Actor((const Dali::Actor &)result);
94500   return jresult;
94501 }
94502
94503
94504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94505   void * jresult ;
94506   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94507   int arg2 ;
94508   Dali::Actor *result = 0 ;
94509
94510   arg1 = (std::vector< Dali::Actor > *)jarg1;
94511   arg2 = (int)jarg2;
94512   {
94513     try {
94514       try {
94515         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94516       }
94517       catch(std::out_of_range &_e) {
94518         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94519         return 0;
94520       }
94521
94522     } catch (std::out_of_range& e) {
94523       {
94524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94525       };
94526     } catch (std::exception& e) {
94527       {
94528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94529       };
94530     } catch (Dali::DaliException e) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94533       };
94534     } catch (...) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94537       };
94538     }
94539   }
94540
94541   jresult = (void *)result;
94542   return jresult;
94543 }
94544
94545
94546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94547   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94548   int arg2 ;
94549   Dali::Actor *arg3 = 0 ;
94550
94551   arg1 = (std::vector< Dali::Actor > *)jarg1;
94552   arg2 = (int)jarg2;
94553   arg3 = (Dali::Actor *)jarg3;
94554   if (!arg3) {
94555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94556     return ;
94557   }
94558   {
94559     try {
94560       try {
94561         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94562       }
94563       catch(std::out_of_range &_e) {
94564         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94565         return ;
94566       }
94567
94568     } catch (std::out_of_range& e) {
94569       {
94570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94571       };
94572     } catch (std::exception& e) {
94573       {
94574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94575       };
94576     } catch (Dali::DaliException e) {
94577       {
94578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94579       };
94580     } catch (...) {
94581       {
94582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94583       };
94584     }
94585   }
94586
94587 }
94588
94589
94590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94591   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94592   std::vector< Dali::Actor > *arg2 = 0 ;
94593
94594   arg1 = (std::vector< Dali::Actor > *)jarg1;
94595   arg2 = (std::vector< Dali::Actor > *)jarg2;
94596   if (!arg2) {
94597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94598     return ;
94599   }
94600   {
94601     try {
94602       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94603     } catch (std::out_of_range& e) {
94604       {
94605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94606       };
94607     } catch (std::exception& e) {
94608       {
94609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94610       };
94611     } catch (Dali::DaliException e) {
94612       {
94613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94614       };
94615     } catch (...) {
94616       {
94617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94618       };
94619     }
94620   }
94621
94622 }
94623
94624
94625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94626   void * jresult ;
94627   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94628   int arg2 ;
94629   int arg3 ;
94630   std::vector< Dali::Actor > *result = 0 ;
94631
94632   arg1 = (std::vector< Dali::Actor > *)jarg1;
94633   arg2 = (int)jarg2;
94634   arg3 = (int)jarg3;
94635   {
94636     try {
94637       try {
94638         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94639       }
94640       catch(std::out_of_range &_e) {
94641         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94642         return 0;
94643       }
94644       catch(std::invalid_argument &_e) {
94645         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94646         return 0;
94647       }
94648
94649     } catch (std::out_of_range& e) {
94650       {
94651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94652       };
94653     } catch (std::exception& e) {
94654       {
94655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94656       };
94657     } catch (Dali::DaliException e) {
94658       {
94659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94660       };
94661     } catch (...) {
94662       {
94663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94664       };
94665     }
94666   }
94667
94668   jresult = (void *)result;
94669   return jresult;
94670 }
94671
94672
94673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94674   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94675   int arg2 ;
94676   Dali::Actor *arg3 = 0 ;
94677
94678   arg1 = (std::vector< Dali::Actor > *)jarg1;
94679   arg2 = (int)jarg2;
94680   arg3 = (Dali::Actor *)jarg3;
94681   if (!arg3) {
94682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94683     return ;
94684   }
94685   {
94686     try {
94687       try {
94688         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94689       }
94690       catch(std::out_of_range &_e) {
94691         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94692         return ;
94693       }
94694
94695     } catch (std::out_of_range& e) {
94696       {
94697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94698       };
94699     } catch (std::exception& e) {
94700       {
94701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94702       };
94703     } catch (Dali::DaliException e) {
94704       {
94705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94706       };
94707     } catch (...) {
94708       {
94709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94710       };
94711     }
94712   }
94713
94714 }
94715
94716
94717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94718   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94719   int arg2 ;
94720   std::vector< Dali::Actor > *arg3 = 0 ;
94721
94722   arg1 = (std::vector< Dali::Actor > *)jarg1;
94723   arg2 = (int)jarg2;
94724   arg3 = (std::vector< Dali::Actor > *)jarg3;
94725   if (!arg3) {
94726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94727     return ;
94728   }
94729   {
94730     try {
94731       try {
94732         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94733       }
94734       catch(std::out_of_range &_e) {
94735         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94736         return ;
94737       }
94738
94739     } catch (std::out_of_range& e) {
94740       {
94741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94742       };
94743     } catch (std::exception& e) {
94744       {
94745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94746       };
94747     } catch (Dali::DaliException e) {
94748       {
94749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94750       };
94751     } catch (...) {
94752       {
94753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94754       };
94755     }
94756   }
94757
94758 }
94759
94760
94761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94762   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94763   int arg2 ;
94764
94765   arg1 = (std::vector< Dali::Actor > *)jarg1;
94766   arg2 = (int)jarg2;
94767   {
94768     try {
94769       try {
94770         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94771       }
94772       catch(std::out_of_range &_e) {
94773         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94774         return ;
94775       }
94776
94777     } catch (std::out_of_range& e) {
94778       {
94779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94780       };
94781     } catch (std::exception& e) {
94782       {
94783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94784       };
94785     } catch (Dali::DaliException e) {
94786       {
94787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94788       };
94789     } catch (...) {
94790       {
94791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94792       };
94793     }
94794   }
94795
94796 }
94797
94798
94799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94800   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94801   int arg2 ;
94802   int arg3 ;
94803
94804   arg1 = (std::vector< Dali::Actor > *)jarg1;
94805   arg2 = (int)jarg2;
94806   arg3 = (int)jarg3;
94807   {
94808     try {
94809       try {
94810         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94811       }
94812       catch(std::out_of_range &_e) {
94813         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94814         return ;
94815       }
94816       catch(std::invalid_argument &_e) {
94817         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94818         return ;
94819       }
94820
94821     } catch (std::out_of_range& e) {
94822       {
94823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94824       };
94825     } catch (std::exception& e) {
94826       {
94827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94828       };
94829     } catch (Dali::DaliException e) {
94830       {
94831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94832       };
94833     } catch (...) {
94834       {
94835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94836       };
94837     }
94838   }
94839
94840 }
94841
94842
94843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94844   void * jresult ;
94845   Dali::Actor *arg1 = 0 ;
94846   int arg2 ;
94847   std::vector< Dali::Actor > *result = 0 ;
94848
94849   arg1 = (Dali::Actor *)jarg1;
94850   if (!arg1) {
94851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94852     return 0;
94853   }
94854   arg2 = (int)jarg2;
94855   {
94856     try {
94857       try {
94858         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94859       }
94860       catch(std::out_of_range &_e) {
94861         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94862         return 0;
94863       }
94864
94865     } catch (std::out_of_range& e) {
94866       {
94867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94868       };
94869     } catch (std::exception& e) {
94870       {
94871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94872       };
94873     } catch (Dali::DaliException e) {
94874       {
94875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94876       };
94877     } catch (...) {
94878       {
94879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94880       };
94881     }
94882   }
94883
94884   jresult = (void *)result;
94885   return jresult;
94886 }
94887
94888
94889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94890   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94891
94892   arg1 = (std::vector< Dali::Actor > *)jarg1;
94893   {
94894     try {
94895       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94896     } catch (std::out_of_range& e) {
94897       {
94898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94899       };
94900     } catch (std::exception& e) {
94901       {
94902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94903       };
94904     } catch (Dali::DaliException e) {
94905       {
94906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94907       };
94908     } catch (...) {
94909       {
94910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94911       };
94912     }
94913   }
94914
94915 }
94916
94917
94918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94919   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94920   int arg2 ;
94921   int arg3 ;
94922
94923   arg1 = (std::vector< Dali::Actor > *)jarg1;
94924   arg2 = (int)jarg2;
94925   arg3 = (int)jarg3;
94926   {
94927     try {
94928       try {
94929         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94930       }
94931       catch(std::out_of_range &_e) {
94932         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94933         return ;
94934       }
94935       catch(std::invalid_argument &_e) {
94936         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94937         return ;
94938       }
94939
94940     } catch (std::out_of_range& e) {
94941       {
94942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94943       };
94944     } catch (std::exception& e) {
94945       {
94946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94947       };
94948     } catch (Dali::DaliException e) {
94949       {
94950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94951       };
94952     } catch (...) {
94953       {
94954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94955       };
94956     }
94957   }
94958
94959 }
94960
94961
94962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94963   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94964   int arg2 ;
94965   std::vector< Dali::Actor > *arg3 = 0 ;
94966
94967   arg1 = (std::vector< Dali::Actor > *)jarg1;
94968   arg2 = (int)jarg2;
94969   arg3 = (std::vector< Dali::Actor > *)jarg3;
94970   if (!arg3) {
94971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94972     return ;
94973   }
94974   {
94975     try {
94976       try {
94977         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94978       }
94979       catch(std::out_of_range &_e) {
94980         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94981         return ;
94982       }
94983
94984     } catch (std::out_of_range& e) {
94985       {
94986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94987       };
94988     } catch (std::exception& e) {
94989       {
94990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94991       };
94992     } catch (Dali::DaliException e) {
94993       {
94994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94995       };
94996     } catch (...) {
94997       {
94998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94999       };
95000     }
95001   }
95002
95003 }
95004
95005
95006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95007   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95008
95009   arg1 = (std::vector< Dali::Actor > *)jarg1;
95010   {
95011     try {
95012       delete arg1;
95013     } catch (std::out_of_range& e) {
95014       {
95015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95016       };
95017     } catch (std::exception& e) {
95018       {
95019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95020       };
95021     } catch (Dali::DaliException e) {
95022       {
95023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95024       };
95025     } catch (...) {
95026       {
95027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95028       };
95029     }
95030   }
95031
95032 }
95033
95034
95035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95036   unsigned int jresult ;
95037   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95038   bool result;
95039
95040   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95041   {
95042     try {
95043       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95044     } catch (std::out_of_range& e) {
95045       {
95046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95047       };
95048     } catch (std::exception& e) {
95049       {
95050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95051       };
95052     } catch (Dali::DaliException e) {
95053       {
95054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95055       };
95056     } catch (...) {
95057       {
95058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95059       };
95060     }
95061   }
95062
95063   jresult = result;
95064   return jresult;
95065 }
95066
95067
95068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95069   unsigned long jresult ;
95070   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95071   std::size_t result;
95072
95073   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95074   {
95075     try {
95076       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95077     } catch (std::out_of_range& e) {
95078       {
95079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95080       };
95081     } catch (std::exception& e) {
95082       {
95083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95084       };
95085     } catch (Dali::DaliException e) {
95086       {
95087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95088       };
95089     } catch (...) {
95090       {
95091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95092       };
95093     }
95094   }
95095
95096   jresult = (unsigned long)result;
95097   return jresult;
95098 }
95099
95100
95101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95102   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95103   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95104
95105   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95106   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95107   {
95108     try {
95109       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95110     } catch (std::out_of_range& e) {
95111       {
95112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95113       };
95114     } catch (std::exception& e) {
95115       {
95116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95117       };
95118     } catch (Dali::DaliException e) {
95119       {
95120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95121       };
95122     } catch (...) {
95123       {
95124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95125       };
95126     }
95127   }
95128
95129 }
95130
95131
95132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95133   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95134   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95135
95136   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95137   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95138   {
95139     try {
95140       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95141     } catch (std::out_of_range& e) {
95142       {
95143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95144       };
95145     } catch (std::exception& e) {
95146       {
95147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95148       };
95149     } catch (Dali::DaliException e) {
95150       {
95151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95152       };
95153     } catch (...) {
95154       {
95155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95156       };
95157     }
95158   }
95159
95160 }
95161
95162
95163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95164   unsigned int jresult ;
95165   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95166   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95167   bool result;
95168
95169   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95170   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95171   if (!arg2) {
95172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95173     return 0;
95174   }
95175   {
95176     try {
95177       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95178     } catch (std::out_of_range& e) {
95179       {
95180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95181       };
95182     } catch (std::exception& e) {
95183       {
95184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95185       };
95186     } catch (Dali::DaliException e) {
95187       {
95188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95189       };
95190     } catch (...) {
95191       {
95192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95193       };
95194     }
95195   }
95196
95197   jresult = result;
95198   return jresult;
95199 }
95200
95201
95202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95203   void * jresult ;
95204   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95205
95206   {
95207     try {
95208       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95209     } catch (std::out_of_range& e) {
95210       {
95211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95212       };
95213     } catch (std::exception& e) {
95214       {
95215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95216       };
95217     } catch (Dali::DaliException e) {
95218       {
95219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95220       };
95221     } catch (...) {
95222       {
95223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95224       };
95225     }
95226   }
95227
95228   jresult = (void *)result;
95229   return jresult;
95230 }
95231
95232
95233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95234   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95235
95236   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95237   {
95238     try {
95239       delete arg1;
95240     } catch (std::out_of_range& e) {
95241       {
95242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95243       };
95244     } catch (std::exception& e) {
95245       {
95246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95247       };
95248     } catch (Dali::DaliException e) {
95249       {
95250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95251       };
95252     } catch (...) {
95253       {
95254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95255       };
95256     }
95257   }
95258
95259 }
95260
95261
95262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95263   unsigned int jresult ;
95264   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95265   bool result;
95266
95267   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95268   {
95269     try {
95270       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);
95271     } catch (std::out_of_range& e) {
95272       {
95273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95274       };
95275     } catch (std::exception& e) {
95276       {
95277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95278       };
95279     } catch (Dali::DaliException e) {
95280       {
95281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95282       };
95283     } catch (...) {
95284       {
95285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95286       };
95287     }
95288   }
95289
95290   jresult = result;
95291   return jresult;
95292 }
95293
95294
95295 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95296   unsigned long jresult ;
95297   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95298   std::size_t result;
95299
95300   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95301   {
95302     try {
95303       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);
95304     } catch (std::out_of_range& e) {
95305       {
95306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95307       };
95308     } catch (std::exception& e) {
95309       {
95310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95311       };
95312     } catch (Dali::DaliException e) {
95313       {
95314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95315       };
95316     } catch (...) {
95317       {
95318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95319       };
95320     }
95321   }
95322
95323   jresult = (unsigned long)result;
95324   return jresult;
95325 }
95326
95327
95328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95329   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95330   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95331
95332   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95333   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95334   {
95335     try {
95336       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95337     } catch (std::out_of_range& e) {
95338       {
95339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95340       };
95341     } catch (std::exception& e) {
95342       {
95343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95344       };
95345     } catch (Dali::DaliException e) {
95346       {
95347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95348       };
95349     } catch (...) {
95350       {
95351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95352       };
95353     }
95354   }
95355
95356 }
95357
95358
95359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95360   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95361   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95362
95363   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95364   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95365   {
95366     try {
95367       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95368     } catch (std::out_of_range& e) {
95369       {
95370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95371       };
95372     } catch (std::exception& e) {
95373       {
95374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95375       };
95376     } catch (Dali::DaliException e) {
95377       {
95378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95379       };
95380     } catch (...) {
95381       {
95382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95383       };
95384     }
95385   }
95386
95387 }
95388
95389
95390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95391   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95392   Dali::Actor arg2 ;
95393   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95394   Dali::Actor *argp2 ;
95395
95396   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95397   argp2 = (Dali::Actor *)jarg2;
95398   if (!argp2) {
95399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95400     return ;
95401   }
95402   arg2 = *argp2;
95403   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95404   {
95405     try {
95406       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95407     } catch (std::out_of_range& e) {
95408       {
95409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95410       };
95411     } catch (std::exception& e) {
95412       {
95413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95414       };
95415     } catch (Dali::DaliException e) {
95416       {
95417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95418       };
95419     } catch (...) {
95420       {
95421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95422       };
95423     }
95424   }
95425
95426 }
95427
95428
95429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95430   void * jresult ;
95431   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95432
95433   {
95434     try {
95435       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95436     } catch (std::out_of_range& e) {
95437       {
95438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95439       };
95440     } catch (std::exception& e) {
95441       {
95442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95443       };
95444     } catch (Dali::DaliException e) {
95445       {
95446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95447       };
95448     } catch (...) {
95449       {
95450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95451       };
95452     }
95453   }
95454
95455   jresult = (void *)result;
95456   return jresult;
95457 }
95458
95459
95460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95461   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95462
95463   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95464   {
95465     try {
95466       delete arg1;
95467     } catch (std::out_of_range& e) {
95468       {
95469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95470       };
95471     } catch (std::exception& e) {
95472       {
95473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95474       };
95475     } catch (Dali::DaliException e) {
95476       {
95477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95478       };
95479     } catch (...) {
95480       {
95481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95482       };
95483     }
95484   }
95485
95486 }
95487
95488
95489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95490   unsigned int jresult ;
95491   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95492   bool result;
95493
95494   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95495   {
95496     try {
95497       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95498     } catch (std::out_of_range& e) {
95499       {
95500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95501       };
95502     } catch (std::exception& e) {
95503       {
95504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95505       };
95506     } catch (Dali::DaliException e) {
95507       {
95508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95509       };
95510     } catch (...) {
95511       {
95512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95513       };
95514     }
95515   }
95516
95517   jresult = result;
95518   return jresult;
95519 }
95520
95521
95522 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95523   unsigned long jresult ;
95524   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95525   std::size_t result;
95526
95527   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95528   {
95529     try {
95530       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95531     } catch (std::out_of_range& e) {
95532       {
95533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95534       };
95535     } catch (std::exception& e) {
95536       {
95537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95538       };
95539     } catch (Dali::DaliException e) {
95540       {
95541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95542       };
95543     } catch (...) {
95544       {
95545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95546       };
95547     }
95548   }
95549
95550   jresult = (unsigned long)result;
95551   return jresult;
95552 }
95553
95554
95555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95556   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95557   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95558
95559   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95560   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95561   {
95562     try {
95563       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95564     } catch (std::out_of_range& e) {
95565       {
95566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95567       };
95568     } catch (std::exception& e) {
95569       {
95570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95571       };
95572     } catch (Dali::DaliException e) {
95573       {
95574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95575       };
95576     } catch (...) {
95577       {
95578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95579       };
95580     }
95581   }
95582
95583 }
95584
95585
95586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95587   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95588   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95589
95590   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95591   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95592   {
95593     try {
95594       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95595     } catch (std::out_of_range& e) {
95596       {
95597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95598       };
95599     } catch (std::exception& e) {
95600       {
95601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95602       };
95603     } catch (Dali::DaliException e) {
95604       {
95605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95606       };
95607     } catch (...) {
95608       {
95609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95610       };
95611     }
95612   }
95613
95614 }
95615
95616
95617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95618   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95619   Dali::Actor arg2 ;
95620   Dali::Actor arg3 ;
95621   Dali::Actor *argp2 ;
95622   Dali::Actor *argp3 ;
95623
95624   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95625   argp2 = (Dali::Actor *)jarg2;
95626   if (!argp2) {
95627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95628     return ;
95629   }
95630   arg2 = *argp2;
95631   argp3 = (Dali::Actor *)jarg3;
95632   if (!argp3) {
95633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95634     return ;
95635   }
95636   arg3 = *argp3;
95637   {
95638     try {
95639       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95640     } catch (std::out_of_range& e) {
95641       {
95642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95643       };
95644     } catch (std::exception& e) {
95645       {
95646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95647       };
95648     } catch (Dali::DaliException e) {
95649       {
95650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95651       };
95652     } catch (...) {
95653       {
95654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95655       };
95656     }
95657   }
95658
95659 }
95660
95661
95662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95663   void * jresult ;
95664   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95665
95666   {
95667     try {
95668       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95669     } catch (std::out_of_range& e) {
95670       {
95671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95672       };
95673     } catch (std::exception& e) {
95674       {
95675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95676       };
95677     } catch (Dali::DaliException e) {
95678       {
95679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95680       };
95681     } catch (...) {
95682       {
95683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95684       };
95685     }
95686   }
95687
95688   jresult = (void *)result;
95689   return jresult;
95690 }
95691
95692
95693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95694   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95695
95696   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95697   {
95698     try {
95699       delete arg1;
95700     } catch (std::out_of_range& e) {
95701       {
95702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95703       };
95704     } catch (std::exception& e) {
95705       {
95706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95707       };
95708     } catch (Dali::DaliException e) {
95709       {
95710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95711       };
95712     } catch (...) {
95713       {
95714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95715       };
95716     }
95717   }
95718
95719 }
95720
95721
95722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95723   unsigned int jresult ;
95724   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95725   bool result;
95726
95727   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95728   {
95729     try {
95730       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95731     } catch (std::out_of_range& e) {
95732       {
95733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95734       };
95735     } catch (std::exception& e) {
95736       {
95737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95738       };
95739     } catch (Dali::DaliException e) {
95740       {
95741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95742       };
95743     } catch (...) {
95744       {
95745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95746       };
95747     }
95748   }
95749
95750   jresult = result;
95751   return jresult;
95752 }
95753
95754
95755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95756   unsigned long jresult ;
95757   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95758   std::size_t result;
95759
95760   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95761   {
95762     try {
95763       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95764     } catch (std::out_of_range& e) {
95765       {
95766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95767       };
95768     } catch (std::exception& e) {
95769       {
95770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95771       };
95772     } catch (Dali::DaliException e) {
95773       {
95774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95775       };
95776     } catch (...) {
95777       {
95778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95779       };
95780     }
95781   }
95782
95783   jresult = (unsigned long)result;
95784   return jresult;
95785 }
95786
95787
95788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95789   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95790   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95791
95792   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95793   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95794   {
95795     try {
95796       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95797     } catch (std::out_of_range& e) {
95798       {
95799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95800       };
95801     } catch (std::exception& e) {
95802       {
95803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95804       };
95805     } catch (Dali::DaliException e) {
95806       {
95807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95808       };
95809     } catch (...) {
95810       {
95811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95812       };
95813     }
95814   }
95815
95816 }
95817
95818
95819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95820   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95821   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95822
95823   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95824   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95825   {
95826     try {
95827       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95828     } catch (std::out_of_range& e) {
95829       {
95830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95831       };
95832     } catch (std::exception& e) {
95833       {
95834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95835       };
95836     } catch (Dali::DaliException e) {
95837       {
95838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95839       };
95840     } catch (...) {
95841       {
95842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95843       };
95844     }
95845   }
95846
95847 }
95848
95849
95850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95851   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95852   Dali::Actor arg2 ;
95853   bool arg3 ;
95854   Dali::Actor *argp2 ;
95855
95856   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95857   argp2 = (Dali::Actor *)jarg2;
95858   if (!argp2) {
95859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95860     return ;
95861   }
95862   arg2 = *argp2;
95863   arg3 = jarg3 ? true : false;
95864   {
95865     try {
95866       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95867     } catch (std::out_of_range& e) {
95868       {
95869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95870       };
95871     } catch (std::exception& e) {
95872       {
95873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95874       };
95875     } catch (Dali::DaliException e) {
95876       {
95877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95878       };
95879     } catch (...) {
95880       {
95881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95882       };
95883     }
95884   }
95885
95886 }
95887
95888
95889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95890   void * jresult ;
95891   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95892
95893   {
95894     try {
95895       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95896     } catch (std::out_of_range& e) {
95897       {
95898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95899       };
95900     } catch (std::exception& e) {
95901       {
95902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95903       };
95904     } catch (Dali::DaliException e) {
95905       {
95906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95907       };
95908     } catch (...) {
95909       {
95910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95911       };
95912     }
95913   }
95914
95915   jresult = (void *)result;
95916   return jresult;
95917 }
95918
95919
95920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95921   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95922
95923   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95924   {
95925     try {
95926       delete arg1;
95927     } catch (std::out_of_range& e) {
95928       {
95929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95930       };
95931     } catch (std::exception& e) {
95932       {
95933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95934       };
95935     } catch (Dali::DaliException e) {
95936       {
95937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95938       };
95939     } catch (...) {
95940       {
95941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95942       };
95943     }
95944   }
95945
95946 }
95947
95948
95949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95950   unsigned int jresult ;
95951   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95952   bool result;
95953
95954   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95955   {
95956     try {
95957       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);
95958     } catch (std::out_of_range& e) {
95959       {
95960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95961       };
95962     } catch (std::exception& e) {
95963       {
95964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95965       };
95966     } catch (Dali::DaliException e) {
95967       {
95968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95969       };
95970     } catch (...) {
95971       {
95972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95973       };
95974     }
95975   }
95976
95977   jresult = result;
95978   return jresult;
95979 }
95980
95981
95982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95983   unsigned long jresult ;
95984   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95985   std::size_t result;
95986
95987   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95988   {
95989     try {
95990       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);
95991     } catch (std::out_of_range& e) {
95992       {
95993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95994       };
95995     } catch (std::exception& e) {
95996       {
95997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95998       };
95999     } catch (Dali::DaliException e) {
96000       {
96001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96002       };
96003     } catch (...) {
96004       {
96005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96006       };
96007     }
96008   }
96009
96010   jresult = (unsigned long)result;
96011   return jresult;
96012 }
96013
96014
96015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96016   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96017   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96018
96019   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96020   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96021   {
96022     try {
96023       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96024     } catch (std::out_of_range& e) {
96025       {
96026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96027       };
96028     } catch (std::exception& e) {
96029       {
96030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96031       };
96032     } catch (Dali::DaliException e) {
96033       {
96034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96035       };
96036     } catch (...) {
96037       {
96038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96039       };
96040     }
96041   }
96042
96043 }
96044
96045
96046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96047   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96048   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96049
96050   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96051   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96052   {
96053     try {
96054       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96055     } catch (std::out_of_range& e) {
96056       {
96057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96058       };
96059     } catch (std::exception& e) {
96060       {
96061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96062       };
96063     } catch (Dali::DaliException e) {
96064       {
96065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96066       };
96067     } catch (...) {
96068       {
96069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96070       };
96071     }
96072   }
96073
96074 }
96075
96076
96077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96078   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96079   Dali::Toolkit::StyleManager arg2 ;
96080   Dali::StyleChange::Type arg3 ;
96081   Dali::Toolkit::StyleManager *argp2 ;
96082
96083   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96084   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96085   if (!argp2) {
96086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96087     return ;
96088   }
96089   arg2 = *argp2;
96090   arg3 = (Dali::StyleChange::Type)jarg3;
96091   {
96092     try {
96093       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96094     } catch (std::out_of_range& e) {
96095       {
96096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96097       };
96098     } catch (std::exception& e) {
96099       {
96100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96101       };
96102     } catch (Dali::DaliException e) {
96103       {
96104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96105       };
96106     } catch (...) {
96107       {
96108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96109       };
96110     }
96111   }
96112
96113 }
96114
96115
96116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96117   void * jresult ;
96118   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96119
96120   {
96121     try {
96122       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96123     } catch (std::out_of_range& e) {
96124       {
96125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96126       };
96127     } catch (std::exception& e) {
96128       {
96129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96130       };
96131     } catch (Dali::DaliException e) {
96132       {
96133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96134       };
96135     } catch (...) {
96136       {
96137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96138       };
96139     }
96140   }
96141
96142   jresult = (void *)result;
96143   return jresult;
96144 }
96145
96146
96147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96148   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96149
96150   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96151   {
96152     try {
96153       delete arg1;
96154     } catch (std::out_of_range& e) {
96155       {
96156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96157       };
96158     } catch (std::exception& e) {
96159       {
96160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96161       };
96162     } catch (Dali::DaliException e) {
96163       {
96164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96165       };
96166     } catch (...) {
96167       {
96168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96169       };
96170     }
96171   }
96172
96173 }
96174
96175
96176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96177   unsigned int jresult ;
96178   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96179   bool result;
96180
96181   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96182   {
96183     try {
96184       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96185     } catch (std::out_of_range& e) {
96186       {
96187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96188       };
96189     } catch (std::exception& e) {
96190       {
96191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96192       };
96193     } catch (Dali::DaliException e) {
96194       {
96195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96196       };
96197     } catch (...) {
96198       {
96199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96200       };
96201     }
96202   }
96203
96204   jresult = result;
96205   return jresult;
96206 }
96207
96208
96209 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96210   unsigned long jresult ;
96211   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96212   std::size_t result;
96213
96214   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96215   {
96216     try {
96217       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96218     } catch (std::out_of_range& e) {
96219       {
96220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96221       };
96222     } catch (std::exception& e) {
96223       {
96224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96225       };
96226     } catch (Dali::DaliException e) {
96227       {
96228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96229       };
96230     } catch (...) {
96231       {
96232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96233       };
96234     }
96235   }
96236
96237   jresult = (unsigned long)result;
96238   return jresult;
96239 }
96240
96241
96242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96243   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96244   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96245
96246   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96247   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96248   {
96249     try {
96250       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96251     } catch (std::out_of_range& e) {
96252       {
96253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96254       };
96255     } catch (std::exception& e) {
96256       {
96257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96258       };
96259     } catch (Dali::DaliException e) {
96260       {
96261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96262       };
96263     } catch (...) {
96264       {
96265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96266       };
96267     }
96268   }
96269
96270 }
96271
96272
96273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96274   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96275   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96276
96277   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96278   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96279   {
96280     try {
96281       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96282     } catch (std::out_of_range& e) {
96283       {
96284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96285       };
96286     } catch (std::exception& e) {
96287       {
96288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96289       };
96290     } catch (Dali::DaliException e) {
96291       {
96292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96293       };
96294     } catch (...) {
96295       {
96296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96297       };
96298     }
96299   }
96300
96301 }
96302
96303
96304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96305   unsigned int jresult ;
96306   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96307   Dali::Toolkit::Button arg2 ;
96308   Dali::Toolkit::Button *argp2 ;
96309   bool result;
96310
96311   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96312   argp2 = (Dali::Toolkit::Button *)jarg2;
96313   if (!argp2) {
96314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96315     return 0;
96316   }
96317   arg2 = *argp2;
96318   {
96319     try {
96320       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96321     } catch (std::out_of_range& e) {
96322       {
96323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96324       };
96325     } catch (std::exception& e) {
96326       {
96327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96328       };
96329     } catch (Dali::DaliException e) {
96330       {
96331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96332       };
96333     } catch (...) {
96334       {
96335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96336       };
96337     }
96338   }
96339
96340   jresult = result;
96341   return jresult;
96342 }
96343
96344
96345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96346   void * jresult ;
96347   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96348
96349   {
96350     try {
96351       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96352     } catch (std::out_of_range& e) {
96353       {
96354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96355       };
96356     } catch (std::exception& e) {
96357       {
96358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96359       };
96360     } catch (Dali::DaliException e) {
96361       {
96362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96363       };
96364     } catch (...) {
96365       {
96366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96367       };
96368     }
96369   }
96370
96371   jresult = (void *)result;
96372   return jresult;
96373 }
96374
96375
96376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96377   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96378
96379   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96380   {
96381     try {
96382       delete arg1;
96383     } catch (std::out_of_range& e) {
96384       {
96385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96386       };
96387     } catch (std::exception& e) {
96388       {
96389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96390       };
96391     } catch (Dali::DaliException e) {
96392       {
96393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96394       };
96395     } catch (...) {
96396       {
96397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96398       };
96399     }
96400   }
96401
96402 }
96403
96404
96405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96406   unsigned int jresult ;
96407   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96408   bool result;
96409
96410   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96411   {
96412     try {
96413       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96414     } catch (std::out_of_range& e) {
96415       {
96416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96417       };
96418     } catch (std::exception& e) {
96419       {
96420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96421       };
96422     } catch (Dali::DaliException e) {
96423       {
96424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96425       };
96426     } catch (...) {
96427       {
96428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96429       };
96430     }
96431   }
96432
96433   jresult = result;
96434   return jresult;
96435 }
96436
96437
96438 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96439   unsigned long jresult ;
96440   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96441   std::size_t result;
96442
96443   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96444   {
96445     try {
96446       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96447     } catch (std::out_of_range& e) {
96448       {
96449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96450       };
96451     } catch (std::exception& e) {
96452       {
96453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96454       };
96455     } catch (Dali::DaliException e) {
96456       {
96457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96458       };
96459     } catch (...) {
96460       {
96461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96462       };
96463     }
96464   }
96465
96466   jresult = (unsigned long)result;
96467   return jresult;
96468 }
96469
96470
96471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96472   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96473   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96474
96475   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96476   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96477   {
96478     try {
96479       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96480     } catch (std::out_of_range& e) {
96481       {
96482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96483       };
96484     } catch (std::exception& e) {
96485       {
96486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96487       };
96488     } catch (Dali::DaliException e) {
96489       {
96490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96491       };
96492     } catch (...) {
96493       {
96494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96495       };
96496     }
96497   }
96498
96499 }
96500
96501
96502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96503   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96504   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96505
96506   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96507   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96508   {
96509     try {
96510       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96511     } catch (std::out_of_range& e) {
96512       {
96513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96514       };
96515     } catch (std::exception& e) {
96516       {
96517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96518       };
96519     } catch (Dali::DaliException e) {
96520       {
96521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96522       };
96523     } catch (...) {
96524       {
96525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96526       };
96527     }
96528   }
96529
96530 }
96531
96532
96533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96534   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96535   Dali::Toolkit::GaussianBlurView arg2 ;
96536   Dali::Toolkit::GaussianBlurView *argp2 ;
96537
96538   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96539   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96540   if (!argp2) {
96541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96542     return ;
96543   }
96544   arg2 = *argp2;
96545   {
96546     try {
96547       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96548     } catch (std::out_of_range& e) {
96549       {
96550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96551       };
96552     } catch (std::exception& e) {
96553       {
96554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96555       };
96556     } catch (Dali::DaliException e) {
96557       {
96558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96559       };
96560     } catch (...) {
96561       {
96562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96563       };
96564     }
96565   }
96566
96567 }
96568
96569
96570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96571   void * jresult ;
96572   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96573
96574   {
96575     try {
96576       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96577     } catch (std::out_of_range& e) {
96578       {
96579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96580       };
96581     } catch (std::exception& e) {
96582       {
96583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96584       };
96585     } catch (Dali::DaliException e) {
96586       {
96587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96588       };
96589     } catch (...) {
96590       {
96591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96592       };
96593     }
96594   }
96595
96596   jresult = (void *)result;
96597   return jresult;
96598 }
96599
96600
96601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96602   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96603
96604   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96605   {
96606     try {
96607       delete arg1;
96608     } catch (std::out_of_range& e) {
96609       {
96610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96611       };
96612     } catch (std::exception& e) {
96613       {
96614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96615       };
96616     } catch (Dali::DaliException e) {
96617       {
96618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96619       };
96620     } catch (...) {
96621       {
96622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96623       };
96624     }
96625   }
96626
96627 }
96628
96629
96630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96631   unsigned int jresult ;
96632   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96633   bool result;
96634
96635   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96636   {
96637     try {
96638       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);
96639     } catch (std::out_of_range& e) {
96640       {
96641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96642       };
96643     } catch (std::exception& e) {
96644       {
96645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96646       };
96647     } catch (Dali::DaliException e) {
96648       {
96649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96650       };
96651     } catch (...) {
96652       {
96653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96654       };
96655     }
96656   }
96657
96658   jresult = result;
96659   return jresult;
96660 }
96661
96662
96663 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96664   unsigned long jresult ;
96665   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96666   std::size_t result;
96667
96668   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96669   {
96670     try {
96671       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);
96672     } catch (std::out_of_range& e) {
96673       {
96674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96675       };
96676     } catch (std::exception& e) {
96677       {
96678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96679       };
96680     } catch (Dali::DaliException e) {
96681       {
96682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96683       };
96684     } catch (...) {
96685       {
96686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96687       };
96688     }
96689   }
96690
96691   jresult = (unsigned long)result;
96692   return jresult;
96693 }
96694
96695
96696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96697   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96698   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96699
96700   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96701   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96702   {
96703     try {
96704       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96705     } catch (std::out_of_range& e) {
96706       {
96707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96708       };
96709     } catch (std::exception& e) {
96710       {
96711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96712       };
96713     } catch (Dali::DaliException e) {
96714       {
96715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96716       };
96717     } catch (...) {
96718       {
96719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96720       };
96721     }
96722   }
96723
96724 }
96725
96726
96727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96728   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96729   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96730
96731   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96732   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96733   {
96734     try {
96735       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96736     } catch (std::out_of_range& e) {
96737       {
96738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96739       };
96740     } catch (std::exception& e) {
96741       {
96742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96743       };
96744     } catch (Dali::DaliException e) {
96745       {
96746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96747       };
96748     } catch (...) {
96749       {
96750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96751       };
96752     }
96753   }
96754
96755 }
96756
96757
96758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96759   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96760   Dali::Toolkit::PageTurnView arg2 ;
96761   unsigned int arg3 ;
96762   bool arg4 ;
96763   Dali::Toolkit::PageTurnView *argp2 ;
96764
96765   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96766   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96767   if (!argp2) {
96768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96769     return ;
96770   }
96771   arg2 = *argp2;
96772   arg3 = (unsigned int)jarg3;
96773   arg4 = jarg4 ? true : false;
96774   {
96775     try {
96776       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96777     } catch (std::out_of_range& e) {
96778       {
96779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96780       };
96781     } catch (std::exception& e) {
96782       {
96783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96784       };
96785     } catch (Dali::DaliException e) {
96786       {
96787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96788       };
96789     } catch (...) {
96790       {
96791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96792       };
96793     }
96794   }
96795
96796 }
96797
96798
96799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96800   void * jresult ;
96801   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96802
96803   {
96804     try {
96805       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96806     } catch (std::out_of_range& e) {
96807       {
96808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96809       };
96810     } catch (std::exception& e) {
96811       {
96812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96813       };
96814     } catch (Dali::DaliException e) {
96815       {
96816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96817       };
96818     } catch (...) {
96819       {
96820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96821       };
96822     }
96823   }
96824
96825   jresult = (void *)result;
96826   return jresult;
96827 }
96828
96829
96830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96831   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96832
96833   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96834   {
96835     try {
96836       delete arg1;
96837     } catch (std::out_of_range& e) {
96838       {
96839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96840       };
96841     } catch (std::exception& e) {
96842       {
96843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96844       };
96845     } catch (Dali::DaliException e) {
96846       {
96847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96848       };
96849     } catch (...) {
96850       {
96851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96852       };
96853     }
96854   }
96855
96856 }
96857
96858
96859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96860   unsigned int jresult ;
96861   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96862   bool result;
96863
96864   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96865   {
96866     try {
96867       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96868     } catch (std::out_of_range& e) {
96869       {
96870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96871       };
96872     } catch (std::exception& e) {
96873       {
96874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96875       };
96876     } catch (Dali::DaliException e) {
96877       {
96878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96879       };
96880     } catch (...) {
96881       {
96882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96883       };
96884     }
96885   }
96886
96887   jresult = result;
96888   return jresult;
96889 }
96890
96891
96892 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96893   unsigned long jresult ;
96894   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96895   std::size_t result;
96896
96897   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96898   {
96899     try {
96900       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96901     } catch (std::out_of_range& e) {
96902       {
96903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96904       };
96905     } catch (std::exception& e) {
96906       {
96907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96908       };
96909     } catch (Dali::DaliException e) {
96910       {
96911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96912       };
96913     } catch (...) {
96914       {
96915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96916       };
96917     }
96918   }
96919
96920   jresult = (unsigned long)result;
96921   return jresult;
96922 }
96923
96924
96925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96926   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96927   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96928
96929   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96930   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96931   {
96932     try {
96933       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96934     } catch (std::out_of_range& e) {
96935       {
96936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96937       };
96938     } catch (std::exception& e) {
96939       {
96940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96941       };
96942     } catch (Dali::DaliException e) {
96943       {
96944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96945       };
96946     } catch (...) {
96947       {
96948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96949       };
96950     }
96951   }
96952
96953 }
96954
96955
96956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96957   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96958   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96959
96960   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96961   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96962   {
96963     try {
96964       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96965     } catch (std::out_of_range& e) {
96966       {
96967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96968       };
96969     } catch (std::exception& e) {
96970       {
96971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96972       };
96973     } catch (Dali::DaliException e) {
96974       {
96975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96976       };
96977     } catch (...) {
96978       {
96979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96980       };
96981     }
96982   }
96983
96984 }
96985
96986
96987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96988   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96989   Dali::Toolkit::PageTurnView arg2 ;
96990   Dali::Toolkit::PageTurnView *argp2 ;
96991
96992   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96993   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96994   if (!argp2) {
96995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96996     return ;
96997   }
96998   arg2 = *argp2;
96999   {
97000     try {
97001       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97002     } catch (std::out_of_range& e) {
97003       {
97004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97005       };
97006     } catch (std::exception& e) {
97007       {
97008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97009       };
97010     } catch (Dali::DaliException e) {
97011       {
97012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97013       };
97014     } catch (...) {
97015       {
97016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97017       };
97018     }
97019   }
97020
97021 }
97022
97023
97024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97025   void * jresult ;
97026   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97027
97028   {
97029     try {
97030       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97031     } catch (std::out_of_range& e) {
97032       {
97033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97034       };
97035     } catch (std::exception& e) {
97036       {
97037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97038       };
97039     } catch (Dali::DaliException e) {
97040       {
97041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97042       };
97043     } catch (...) {
97044       {
97045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97046       };
97047     }
97048   }
97049
97050   jresult = (void *)result;
97051   return jresult;
97052 }
97053
97054
97055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97056   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97057
97058   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97059   {
97060     try {
97061       delete arg1;
97062     } catch (std::out_of_range& e) {
97063       {
97064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97065       };
97066     } catch (std::exception& e) {
97067       {
97068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97069       };
97070     } catch (Dali::DaliException e) {
97071       {
97072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97073       };
97074     } catch (...) {
97075       {
97076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97077       };
97078     }
97079   }
97080
97081 }
97082
97083
97084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97085   unsigned int jresult ;
97086   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97087   bool result;
97088
97089   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97090   {
97091     try {
97092       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);
97093     } catch (std::out_of_range& e) {
97094       {
97095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97096       };
97097     } catch (std::exception& e) {
97098       {
97099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97100       };
97101     } catch (Dali::DaliException e) {
97102       {
97103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97104       };
97105     } catch (...) {
97106       {
97107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97108       };
97109     }
97110   }
97111
97112   jresult = result;
97113   return jresult;
97114 }
97115
97116
97117 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97118   unsigned long jresult ;
97119   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97120   std::size_t result;
97121
97122   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97123   {
97124     try {
97125       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);
97126     } catch (std::out_of_range& e) {
97127       {
97128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97129       };
97130     } catch (std::exception& e) {
97131       {
97132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97133       };
97134     } catch (Dali::DaliException e) {
97135       {
97136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97137       };
97138     } catch (...) {
97139       {
97140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97141       };
97142     }
97143   }
97144
97145   jresult = (unsigned long)result;
97146   return jresult;
97147 }
97148
97149
97150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97151   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97152   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97153
97154   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97155   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97156   {
97157     try {
97158       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97159     } catch (std::out_of_range& e) {
97160       {
97161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97162       };
97163     } catch (std::exception& e) {
97164       {
97165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97166       };
97167     } catch (Dali::DaliException e) {
97168       {
97169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97170       };
97171     } catch (...) {
97172       {
97173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97174       };
97175     }
97176   }
97177
97178 }
97179
97180
97181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97182   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97183   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97184
97185   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97186   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97187   {
97188     try {
97189       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97190     } catch (std::out_of_range& e) {
97191       {
97192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97193       };
97194     } catch (std::exception& e) {
97195       {
97196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97197       };
97198     } catch (Dali::DaliException e) {
97199       {
97200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97201       };
97202     } catch (...) {
97203       {
97204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97205       };
97206     }
97207   }
97208
97209 }
97210
97211
97212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97213   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97214   Dali::Toolkit::ProgressBar arg2 ;
97215   float arg3 ;
97216   float arg4 ;
97217   Dali::Toolkit::ProgressBar *argp2 ;
97218
97219   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97220   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97221   if (!argp2) {
97222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97223     return ;
97224   }
97225   arg2 = *argp2;
97226   arg3 = (float)jarg3;
97227   arg4 = (float)jarg4;
97228   {
97229     try {
97230       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97231     } catch (std::out_of_range& e) {
97232       {
97233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97234       };
97235     } catch (std::exception& e) {
97236       {
97237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97238       };
97239     } catch (Dali::DaliException e) {
97240       {
97241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97242       };
97243     } catch (...) {
97244       {
97245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97246       };
97247     }
97248   }
97249
97250 }
97251
97252
97253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97254   void * jresult ;
97255   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97256
97257   {
97258     try {
97259       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97260     } catch (std::out_of_range& e) {
97261       {
97262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97263       };
97264     } catch (std::exception& e) {
97265       {
97266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97267       };
97268     } catch (Dali::DaliException e) {
97269       {
97270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97271       };
97272     } catch (...) {
97273       {
97274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97275       };
97276     }
97277   }
97278
97279   jresult = (void *)result;
97280   return jresult;
97281 }
97282
97283
97284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97285   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97286
97287   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97288   {
97289     try {
97290       delete arg1;
97291     } catch (std::out_of_range& e) {
97292       {
97293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97294       };
97295     } catch (std::exception& e) {
97296       {
97297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97298       };
97299     } catch (Dali::DaliException e) {
97300       {
97301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97302       };
97303     } catch (...) {
97304       {
97305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97306       };
97307     }
97308   }
97309
97310 }
97311
97312
97313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97314   unsigned int jresult ;
97315   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97316   bool result;
97317
97318   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97319   {
97320     try {
97321       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);
97322     } catch (std::out_of_range& e) {
97323       {
97324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97325       };
97326     } catch (std::exception& e) {
97327       {
97328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97329       };
97330     } catch (Dali::DaliException e) {
97331       {
97332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97333       };
97334     } catch (...) {
97335       {
97336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97337       };
97338     }
97339   }
97340
97341   jresult = result;
97342   return jresult;
97343 }
97344
97345
97346 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97347   unsigned long jresult ;
97348   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97349   std::size_t result;
97350
97351   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97352   {
97353     try {
97354       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);
97355     } catch (std::out_of_range& e) {
97356       {
97357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97358       };
97359     } catch (std::exception& e) {
97360       {
97361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97362       };
97363     } catch (Dali::DaliException e) {
97364       {
97365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97366       };
97367     } catch (...) {
97368       {
97369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97370       };
97371     }
97372   }
97373
97374   jresult = (unsigned long)result;
97375   return jresult;
97376 }
97377
97378
97379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97380   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97381   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97382
97383   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97384   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97385   {
97386     try {
97387       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97388     } catch (std::out_of_range& e) {
97389       {
97390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97391       };
97392     } catch (std::exception& e) {
97393       {
97394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97395       };
97396     } catch (Dali::DaliException e) {
97397       {
97398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97399       };
97400     } catch (...) {
97401       {
97402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97403       };
97404     }
97405   }
97406
97407 }
97408
97409
97410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97411   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97412   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97413
97414   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97415   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97416   {
97417     try {
97418       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97419     } catch (std::out_of_range& e) {
97420       {
97421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97422       };
97423     } catch (std::exception& e) {
97424       {
97425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97426       };
97427     } catch (Dali::DaliException e) {
97428       {
97429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97430       };
97431     } catch (...) {
97432       {
97433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97434       };
97435     }
97436   }
97437
97438 }
97439
97440
97441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97442   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97443   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97444
97445   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97446   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97447   if (!arg2) {
97448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97449     return ;
97450   }
97451   {
97452     try {
97453       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97454     } catch (std::out_of_range& e) {
97455       {
97456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97457       };
97458     } catch (std::exception& e) {
97459       {
97460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97461       };
97462     } catch (Dali::DaliException e) {
97463       {
97464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97465       };
97466     } catch (...) {
97467       {
97468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97469       };
97470     }
97471   }
97472
97473 }
97474
97475
97476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97477   void * jresult ;
97478   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97479
97480   {
97481     try {
97482       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97483     } catch (std::out_of_range& e) {
97484       {
97485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97486       };
97487     } catch (std::exception& e) {
97488       {
97489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97490       };
97491     } catch (Dali::DaliException e) {
97492       {
97493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97494       };
97495     } catch (...) {
97496       {
97497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97498       };
97499     }
97500   }
97501
97502   jresult = (void *)result;
97503   return jresult;
97504 }
97505
97506
97507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97508   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97509
97510   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97511   {
97512     try {
97513       delete arg1;
97514     } catch (std::out_of_range& e) {
97515       {
97516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97517       };
97518     } catch (std::exception& e) {
97519       {
97520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97521       };
97522     } catch (Dali::DaliException e) {
97523       {
97524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97525       };
97526     } catch (...) {
97527       {
97528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97529       };
97530     }
97531   }
97532
97533 }
97534
97535
97536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97537   unsigned int jresult ;
97538   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97539   bool result;
97540
97541   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97542   {
97543     try {
97544       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97545     } catch (std::out_of_range& e) {
97546       {
97547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97548       };
97549     } catch (std::exception& e) {
97550       {
97551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97552       };
97553     } catch (Dali::DaliException e) {
97554       {
97555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97556       };
97557     } catch (...) {
97558       {
97559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97560       };
97561     }
97562   }
97563
97564   jresult = result;
97565   return jresult;
97566 }
97567
97568
97569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97570   unsigned long jresult ;
97571   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97572   std::size_t result;
97573
97574   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97575   {
97576     try {
97577       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97578     } catch (std::out_of_range& e) {
97579       {
97580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97581       };
97582     } catch (std::exception& e) {
97583       {
97584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97585       };
97586     } catch (Dali::DaliException e) {
97587       {
97588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97589       };
97590     } catch (...) {
97591       {
97592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97593       };
97594     }
97595   }
97596
97597   jresult = (unsigned long)result;
97598   return jresult;
97599 }
97600
97601
97602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97603   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97604   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97605
97606   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97607   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97608   {
97609     try {
97610       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97611     } catch (std::out_of_range& e) {
97612       {
97613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97614       };
97615     } catch (std::exception& e) {
97616       {
97617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97618       };
97619     } catch (Dali::DaliException e) {
97620       {
97621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97622       };
97623     } catch (...) {
97624       {
97625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97626       };
97627     }
97628   }
97629
97630 }
97631
97632
97633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97634   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97635   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97636
97637   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97638   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97639   {
97640     try {
97641       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97642     } catch (std::out_of_range& e) {
97643       {
97644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97645       };
97646     } catch (std::exception& e) {
97647       {
97648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97649       };
97650     } catch (Dali::DaliException e) {
97651       {
97652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97653       };
97654     } catch (...) {
97655       {
97656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97657       };
97658     }
97659   }
97660
97661 }
97662
97663
97664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97665   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97666   Dali::Vector2 *arg2 = 0 ;
97667
97668   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97669   arg2 = (Dali::Vector2 *)jarg2;
97670   if (!arg2) {
97671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97672     return ;
97673   }
97674   {
97675     try {
97676       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97677     } catch (std::out_of_range& e) {
97678       {
97679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97680       };
97681     } catch (std::exception& e) {
97682       {
97683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97684       };
97685     } catch (Dali::DaliException e) {
97686       {
97687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97688       };
97689     } catch (...) {
97690       {
97691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97692       };
97693     }
97694   }
97695
97696 }
97697
97698
97699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97700   void * jresult ;
97701   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97702
97703   {
97704     try {
97705       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97706     } catch (std::out_of_range& e) {
97707       {
97708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97709       };
97710     } catch (std::exception& e) {
97711       {
97712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97713       };
97714     } catch (Dali::DaliException e) {
97715       {
97716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97717       };
97718     } catch (...) {
97719       {
97720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97721       };
97722     }
97723   }
97724
97725   jresult = (void *)result;
97726   return jresult;
97727 }
97728
97729
97730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97731   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97732
97733   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97734   {
97735     try {
97736       delete arg1;
97737     } catch (std::out_of_range& e) {
97738       {
97739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97740       };
97741     } catch (std::exception& e) {
97742       {
97743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97744       };
97745     } catch (Dali::DaliException e) {
97746       {
97747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97748       };
97749     } catch (...) {
97750       {
97751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97752       };
97753     }
97754   }
97755
97756 }
97757
97758
97759
97760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97761   unsigned int jresult ;
97762   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97763   bool result;
97764
97765   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97766   {
97767     try {
97768       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);
97769     } catch (std::out_of_range& e) {
97770       {
97771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97772       };
97773     } catch (std::exception& e) {
97774       {
97775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97776       };
97777     } catch (Dali::DaliException e) {
97778       {
97779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97780       };
97781     } catch (...) {
97782       {
97783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97784       };
97785     }
97786   }
97787
97788   jresult = result;
97789   return jresult;
97790 }
97791
97792
97793 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97794   unsigned long jresult ;
97795   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97796   std::size_t result;
97797
97798   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97799   {
97800     try {
97801       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);
97802     } catch (std::out_of_range& e) {
97803       {
97804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97805       };
97806     } catch (std::exception& e) {
97807       {
97808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97809       };
97810     } catch (Dali::DaliException e) {
97811       {
97812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97813       };
97814     } catch (...) {
97815       {
97816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97817       };
97818     }
97819   }
97820
97821   jresult = (unsigned long)result;
97822   return jresult;
97823 }
97824
97825
97826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97827   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97828   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97829
97830   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97831   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97832   {
97833     try {
97834       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97835     } catch (std::out_of_range& e) {
97836       {
97837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97838       };
97839     } catch (std::exception& e) {
97840       {
97841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97842       };
97843     } catch (Dali::DaliException e) {
97844       {
97845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97846       };
97847     } catch (...) {
97848       {
97849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97850       };
97851     }
97852   }
97853
97854 }
97855
97856
97857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97858   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97859   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97860
97861   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97862   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97863   {
97864     try {
97865       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97866     } catch (std::out_of_range& e) {
97867       {
97868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97869       };
97870     } catch (std::exception& e) {
97871       {
97872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97873       };
97874     } catch (Dali::DaliException e) {
97875       {
97876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97877       };
97878     } catch (...) {
97879       {
97880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97881       };
97882     }
97883   }
97884
97885 }
97886
97887
97888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97889   unsigned int jresult ;
97890   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97891   Dali::Toolkit::Control arg2 ;
97892   Dali::KeyEvent *arg3 = 0 ;
97893   Dali::Toolkit::Control *argp2 ;
97894   bool result;
97895
97896   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97897   argp2 = (Dali::Toolkit::Control *)jarg2;
97898   if (!argp2) {
97899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97900     return 0;
97901   }
97902   arg2 = *argp2;
97903   arg3 = (Dali::KeyEvent *)jarg3;
97904   if (!arg3) {
97905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97906     return 0;
97907   }
97908   {
97909     try {
97910       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);
97911     } catch (std::out_of_range& e) {
97912       {
97913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97914       };
97915     } catch (std::exception& e) {
97916       {
97917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97918       };
97919     } catch (Dali::DaliException e) {
97920       {
97921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97922       };
97923     } catch (...) {
97924       {
97925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97926       };
97927     }
97928   }
97929
97930   jresult = result;
97931   return jresult;
97932 }
97933
97934
97935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97936   void * jresult ;
97937   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97938
97939   {
97940     try {
97941       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97942     } catch (std::out_of_range& e) {
97943       {
97944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97945       };
97946     } catch (std::exception& e) {
97947       {
97948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97949       };
97950     } catch (Dali::DaliException e) {
97951       {
97952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97953       };
97954     } catch (...) {
97955       {
97956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97957       };
97958     }
97959   }
97960
97961   jresult = (void *)result;
97962   return jresult;
97963 }
97964
97965
97966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97967   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97968
97969   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97970   {
97971     try {
97972       delete arg1;
97973     } catch (std::out_of_range& e) {
97974       {
97975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97976       };
97977     } catch (std::exception& e) {
97978       {
97979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97980       };
97981     } catch (Dali::DaliException e) {
97982       {
97983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97984       };
97985     } catch (...) {
97986       {
97987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97988       };
97989     }
97990   }
97991
97992 }
97993
97994
97995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97996   unsigned int jresult ;
97997   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97998   bool result;
97999
98000   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98001   {
98002     try {
98003       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98004     } catch (std::out_of_range& e) {
98005       {
98006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98007       };
98008     } catch (std::exception& e) {
98009       {
98010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98011       };
98012     } catch (Dali::DaliException e) {
98013       {
98014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98015       };
98016     } catch (...) {
98017       {
98018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98019       };
98020     }
98021   }
98022
98023   jresult = result;
98024   return jresult;
98025 }
98026
98027
98028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98029   unsigned long jresult ;
98030   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98031   std::size_t result;
98032
98033   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98034   {
98035     try {
98036       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98037     } catch (std::out_of_range& e) {
98038       {
98039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98040       };
98041     } catch (std::exception& e) {
98042       {
98043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98044       };
98045     } catch (Dali::DaliException e) {
98046       {
98047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98048       };
98049     } catch (...) {
98050       {
98051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98052       };
98053     }
98054   }
98055
98056   jresult = (unsigned long)result;
98057   return jresult;
98058 }
98059
98060
98061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98062   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98063   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98064
98065   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98066   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98067   {
98068     try {
98069       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98070     } catch (std::out_of_range& e) {
98071       {
98072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98073       };
98074     } catch (std::exception& e) {
98075       {
98076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98077       };
98078     } catch (Dali::DaliException e) {
98079       {
98080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98081       };
98082     } catch (...) {
98083       {
98084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98085       };
98086     }
98087   }
98088
98089 }
98090
98091
98092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98093   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98094   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98095
98096   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98097   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98098   {
98099     try {
98100       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98101     } catch (std::out_of_range& e) {
98102       {
98103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98104       };
98105     } catch (std::exception& e) {
98106       {
98107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98108       };
98109     } catch (Dali::DaliException e) {
98110       {
98111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98112       };
98113     } catch (...) {
98114       {
98115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98116       };
98117     }
98118   }
98119
98120 }
98121
98122
98123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98124   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98125   Dali::Toolkit::Control arg2 ;
98126   Dali::Toolkit::Control *argp2 ;
98127
98128   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98129   argp2 = (Dali::Toolkit::Control *)jarg2;
98130   if (!argp2) {
98131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98132     return ;
98133   }
98134   arg2 = *argp2;
98135   {
98136     try {
98137       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98138     } catch (std::out_of_range& e) {
98139       {
98140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98141       };
98142     } catch (std::exception& e) {
98143       {
98144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98145       };
98146     } catch (Dali::DaliException e) {
98147       {
98148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98149       };
98150     } catch (...) {
98151       {
98152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98153       };
98154     }
98155   }
98156
98157 }
98158
98159
98160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98161   void * jresult ;
98162   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98163
98164   {
98165     try {
98166       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98167     } catch (std::out_of_range& e) {
98168       {
98169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98170       };
98171     } catch (std::exception& e) {
98172       {
98173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98174       };
98175     } catch (Dali::DaliException e) {
98176       {
98177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98178       };
98179     } catch (...) {
98180       {
98181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98182       };
98183     }
98184   }
98185
98186   jresult = (void *)result;
98187   return jresult;
98188 }
98189
98190
98191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98192   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98193
98194   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98195   {
98196     try {
98197       delete arg1;
98198     } catch (std::out_of_range& e) {
98199       {
98200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98201       };
98202     } catch (std::exception& e) {
98203       {
98204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98205       };
98206     } catch (Dali::DaliException e) {
98207       {
98208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98209       };
98210     } catch (...) {
98211       {
98212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98213       };
98214     }
98215   }
98216
98217 }
98218
98219
98220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98221   unsigned int jresult ;
98222   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98223   bool result;
98224
98225   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98226   {
98227     try {
98228       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98229     } catch (std::out_of_range& e) {
98230       {
98231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98232       };
98233     } catch (std::exception& e) {
98234       {
98235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98236       };
98237     } catch (Dali::DaliException e) {
98238       {
98239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98240       };
98241     } catch (...) {
98242       {
98243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98244       };
98245     }
98246   }
98247
98248   jresult = result;
98249   return jresult;
98250 }
98251
98252
98253 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98254   unsigned long jresult ;
98255   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98256   std::size_t result;
98257
98258   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98259   {
98260     try {
98261       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98262     } catch (std::out_of_range& e) {
98263       {
98264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98265       };
98266     } catch (std::exception& e) {
98267       {
98268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98269       };
98270     } catch (Dali::DaliException e) {
98271       {
98272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98273       };
98274     } catch (...) {
98275       {
98276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98277       };
98278     }
98279   }
98280
98281   jresult = (unsigned long)result;
98282   return jresult;
98283 }
98284
98285
98286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98287   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98288   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98289
98290   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98291   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98292   {
98293     try {
98294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98295     } catch (std::out_of_range& e) {
98296       {
98297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98298       };
98299     } catch (std::exception& e) {
98300       {
98301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98302       };
98303     } catch (Dali::DaliException e) {
98304       {
98305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98306       };
98307     } catch (...) {
98308       {
98309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98310       };
98311     }
98312   }
98313
98314 }
98315
98316
98317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98318   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98319   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98320
98321   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98322   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98323   {
98324     try {
98325       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98326     } catch (std::out_of_range& e) {
98327       {
98328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98329       };
98330     } catch (std::exception& e) {
98331       {
98332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98333       };
98334     } catch (Dali::DaliException e) {
98335       {
98336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98337       };
98338     } catch (...) {
98339       {
98340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98341       };
98342     }
98343   }
98344
98345 }
98346
98347
98348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98349   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98350   Dali::Toolkit::VideoView *arg2 = 0 ;
98351
98352   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98353   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98354   if (!arg2) {
98355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98356     return ;
98357   }
98358   {
98359     try {
98360       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98361     } catch (std::out_of_range& e) {
98362       {
98363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98364       };
98365     } catch (std::exception& e) {
98366       {
98367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98368       };
98369     } catch (Dali::DaliException e) {
98370       {
98371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98372       };
98373     } catch (...) {
98374       {
98375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98376       };
98377     }
98378   }
98379
98380 }
98381
98382
98383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98384   void * jresult ;
98385   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98386
98387   {
98388     try {
98389       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98390     } catch (std::out_of_range& e) {
98391       {
98392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98393       };
98394     } catch (std::exception& e) {
98395       {
98396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98397       };
98398     } catch (Dali::DaliException e) {
98399       {
98400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98401       };
98402     } catch (...) {
98403       {
98404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98405       };
98406     }
98407   }
98408
98409   jresult = (void *)result;
98410   return jresult;
98411 }
98412
98413
98414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98415   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98416
98417   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98418   {
98419     try {
98420       delete arg1;
98421     } catch (std::out_of_range& e) {
98422       {
98423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98424       };
98425     } catch (std::exception& e) {
98426       {
98427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98428       };
98429     } catch (Dali::DaliException e) {
98430       {
98431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98432       };
98433     } catch (...) {
98434       {
98435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98436       };
98437     }
98438   }
98439
98440 }
98441
98442
98443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98444   unsigned int jresult ;
98445   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98446   bool result;
98447
98448   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98449   {
98450     try {
98451       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98452     } catch (std::out_of_range& e) {
98453       {
98454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98455       };
98456     } catch (std::exception& e) {
98457       {
98458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98459       };
98460     } catch (Dali::DaliException e) {
98461       {
98462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98463       };
98464     } catch (...) {
98465       {
98466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98467       };
98468     }
98469   }
98470
98471   jresult = result;
98472   return jresult;
98473 }
98474
98475
98476 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98477   unsigned long jresult ;
98478   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98479   std::size_t result;
98480
98481   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98482   {
98483     try {
98484       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98485     } catch (std::out_of_range& e) {
98486       {
98487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98488       };
98489     } catch (std::exception& e) {
98490       {
98491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98492       };
98493     } catch (Dali::DaliException e) {
98494       {
98495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98496       };
98497     } catch (...) {
98498       {
98499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98500       };
98501     }
98502   }
98503
98504   jresult = (unsigned long)result;
98505   return jresult;
98506 }
98507
98508
98509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98510   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98511   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98512
98513   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98514   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98515   {
98516     try {
98517       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98518     } catch (std::out_of_range& e) {
98519       {
98520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98521       };
98522     } catch (std::exception& e) {
98523       {
98524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98525       };
98526     } catch (Dali::DaliException e) {
98527       {
98528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98529       };
98530     } catch (...) {
98531       {
98532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98533       };
98534     }
98535   }
98536
98537 }
98538
98539
98540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98541   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98542   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98543
98544   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98545   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98546   {
98547     try {
98548       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98549     } catch (std::out_of_range& e) {
98550       {
98551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98552       };
98553     } catch (std::exception& e) {
98554       {
98555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98556       };
98557     } catch (Dali::DaliException e) {
98558       {
98559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98560       };
98561     } catch (...) {
98562       {
98563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98564       };
98565     }
98566   }
98567
98568 }
98569
98570
98571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98572   unsigned int jresult ;
98573   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98574   Dali::Toolkit::Slider arg2 ;
98575   float arg3 ;
98576   Dali::Toolkit::Slider *argp2 ;
98577   bool result;
98578
98579   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98580   argp2 = (Dali::Toolkit::Slider *)jarg2;
98581   if (!argp2) {
98582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98583     return 0;
98584   }
98585   arg2 = *argp2;
98586   arg3 = (float)jarg3;
98587   {
98588     try {
98589       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98590     } catch (std::out_of_range& e) {
98591       {
98592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98593       };
98594     } catch (std::exception& e) {
98595       {
98596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98597       };
98598     } catch (Dali::DaliException e) {
98599       {
98600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98601       };
98602     } catch (...) {
98603       {
98604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98605       };
98606     }
98607   }
98608
98609   jresult = result;
98610   return jresult;
98611 }
98612
98613
98614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98615   void * jresult ;
98616   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98617
98618   {
98619     try {
98620       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98621     } catch (std::out_of_range& e) {
98622       {
98623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98624       };
98625     } catch (std::exception& e) {
98626       {
98627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98628       };
98629     } catch (Dali::DaliException e) {
98630       {
98631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98632       };
98633     } catch (...) {
98634       {
98635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98636       };
98637     }
98638   }
98639
98640   jresult = (void *)result;
98641   return jresult;
98642 }
98643
98644
98645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98646   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98647
98648   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98649   {
98650     try {
98651       delete arg1;
98652     } catch (std::out_of_range& e) {
98653       {
98654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98655       };
98656     } catch (std::exception& e) {
98657       {
98658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98659       };
98660     } catch (Dali::DaliException e) {
98661       {
98662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98663       };
98664     } catch (...) {
98665       {
98666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98667       };
98668     }
98669   }
98670
98671 }
98672
98673
98674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98675   unsigned int jresult ;
98676   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98677   bool result;
98678
98679   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98680   {
98681     try {
98682       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98683     } catch (std::out_of_range& e) {
98684       {
98685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98686       };
98687     } catch (std::exception& e) {
98688       {
98689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98690       };
98691     } catch (Dali::DaliException e) {
98692       {
98693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98694       };
98695     } catch (...) {
98696       {
98697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98698       };
98699     }
98700   }
98701
98702   jresult = result;
98703   return jresult;
98704 }
98705
98706
98707 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98708   unsigned long jresult ;
98709   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98710   std::size_t result;
98711
98712   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98713   {
98714     try {
98715       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98716     } catch (std::out_of_range& e) {
98717       {
98718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98719       };
98720     } catch (std::exception& e) {
98721       {
98722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98723       };
98724     } catch (Dali::DaliException e) {
98725       {
98726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98727       };
98728     } catch (...) {
98729       {
98730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98731       };
98732     }
98733   }
98734
98735   jresult = (unsigned long)result;
98736   return jresult;
98737 }
98738
98739
98740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98741   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98742   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98743
98744   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98745   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98746   {
98747     try {
98748       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98749     } catch (std::out_of_range& e) {
98750       {
98751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98752       };
98753     } catch (std::exception& e) {
98754       {
98755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98756       };
98757     } catch (Dali::DaliException e) {
98758       {
98759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98760       };
98761     } catch (...) {
98762       {
98763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98764       };
98765     }
98766   }
98767
98768 }
98769
98770
98771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98772   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98773   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98774
98775   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98776   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98777   {
98778     try {
98779       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98780     } catch (std::out_of_range& e) {
98781       {
98782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98783       };
98784     } catch (std::exception& e) {
98785       {
98786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98787       };
98788     } catch (Dali::DaliException e) {
98789       {
98790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98791       };
98792     } catch (...) {
98793       {
98794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98795       };
98796     }
98797   }
98798
98799 }
98800
98801
98802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98803   unsigned int jresult ;
98804   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98805   Dali::Toolkit::Slider arg2 ;
98806   int arg3 ;
98807   Dali::Toolkit::Slider *argp2 ;
98808   bool result;
98809
98810   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98811   argp2 = (Dali::Toolkit::Slider *)jarg2;
98812   if (!argp2) {
98813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98814     return 0;
98815   }
98816   arg2 = *argp2;
98817   arg3 = (int)jarg3;
98818   {
98819     try {
98820       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98821     } catch (std::out_of_range& e) {
98822       {
98823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98824       };
98825     } catch (std::exception& e) {
98826       {
98827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98828       };
98829     } catch (Dali::DaliException e) {
98830       {
98831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98832       };
98833     } catch (...) {
98834       {
98835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98836       };
98837     }
98838   }
98839
98840   jresult = result;
98841   return jresult;
98842 }
98843
98844
98845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98846   void * jresult ;
98847   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98848
98849   {
98850     try {
98851       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98852     } catch (std::out_of_range& e) {
98853       {
98854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98855       };
98856     } catch (std::exception& e) {
98857       {
98858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98859       };
98860     } catch (Dali::DaliException e) {
98861       {
98862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98863       };
98864     } catch (...) {
98865       {
98866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98867       };
98868     }
98869   }
98870
98871   jresult = (void *)result;
98872   return jresult;
98873 }
98874
98875
98876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98877   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98878
98879   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98880   {
98881     try {
98882       delete arg1;
98883     } catch (std::out_of_range& e) {
98884       {
98885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98886       };
98887     } catch (std::exception& e) {
98888       {
98889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98890       };
98891     } catch (Dali::DaliException e) {
98892       {
98893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98894       };
98895     } catch (...) {
98896       {
98897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98898       };
98899     }
98900   }
98901
98902 }
98903
98904
98905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98906   void * jresult ;
98907   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98908
98909   {
98910     try {
98911       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98912     } catch (std::out_of_range& e) {
98913       {
98914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98915       };
98916     } catch (std::exception& e) {
98917       {
98918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98919       };
98920     } catch (Dali::DaliException e) {
98921       {
98922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98923       };
98924     } catch (...) {
98925       {
98926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98927       };
98928     }
98929   }
98930
98931   jresult = (void *)result;
98932   return jresult;
98933 }
98934
98935
98936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98937   void * jresult ;
98938   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98939   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98940
98941   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98942   {
98943     try {
98944       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98945     } catch (std::out_of_range& e) {
98946       {
98947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98948       };
98949     } catch (std::exception& e) {
98950       {
98951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98952       };
98953     } catch (Dali::DaliException e) {
98954       {
98955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98956       };
98957     } catch (...) {
98958       {
98959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98960       };
98961     }
98962   }
98963
98964   jresult = (void *)result;
98965   return jresult;
98966 }
98967
98968
98969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98970   void * jresult ;
98971   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98972   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98973
98974   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98975   if (!arg1) {
98976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98977     return 0;
98978   }
98979   {
98980     try {
98981       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98982     } catch (std::out_of_range& e) {
98983       {
98984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98985       };
98986     } catch (std::exception& e) {
98987       {
98988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98989       };
98990     } catch (Dali::DaliException e) {
98991       {
98992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98993       };
98994     } catch (...) {
98995       {
98996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98997       };
98998     }
98999   }
99000
99001   jresult = (void *)result;
99002   return jresult;
99003 }
99004
99005
99006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99007   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99008
99009   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99010   {
99011     try {
99012       delete arg1;
99013     } catch (std::out_of_range& e) {
99014       {
99015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99016       };
99017     } catch (std::exception& e) {
99018       {
99019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99020       };
99021     } catch (Dali::DaliException e) {
99022       {
99023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99024       };
99025     } catch (...) {
99026       {
99027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99028       };
99029     }
99030   }
99031
99032 }
99033
99034
99035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99036   void * jresult ;
99037   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99038   Dali::Toolkit::Ruler *result = 0 ;
99039
99040   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99041   {
99042     try {
99043       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99044     } catch (std::out_of_range& e) {
99045       {
99046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99047       };
99048     } catch (std::exception& e) {
99049       {
99050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99051       };
99052     } catch (Dali::DaliException e) {
99053       {
99054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99055       };
99056     } catch (...) {
99057       {
99058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99059       };
99060     }
99061   }
99062
99063   jresult = (void *)result;
99064   return jresult;
99065 }
99066
99067
99068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99069   void * jresult ;
99070   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99071   Dali::Toolkit::Ruler *result = 0 ;
99072
99073   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99074   {
99075     try {
99076       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99077     } catch (std::out_of_range& e) {
99078       {
99079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99080       };
99081     } catch (std::exception& e) {
99082       {
99083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99084       };
99085     } catch (Dali::DaliException e) {
99086       {
99087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99088       };
99089     } catch (...) {
99090       {
99091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99092       };
99093     }
99094   }
99095
99096   jresult = (void *)result;
99097   return jresult;
99098 }
99099
99100
99101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99102   void * jresult ;
99103   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99104   Dali::Toolkit::Ruler *result = 0 ;
99105
99106   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99107   {
99108     try {
99109       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99110     } catch (std::out_of_range& e) {
99111       {
99112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99113       };
99114     } catch (std::exception& e) {
99115       {
99116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99117       };
99118     } catch (Dali::DaliException e) {
99119       {
99120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99121       };
99122     } catch (...) {
99123       {
99124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99125       };
99126     }
99127   }
99128
99129   jresult = (void *)result;
99130   return jresult;
99131 }
99132
99133
99134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99135   void * jresult ;
99136   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99137   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99138   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99139
99140   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99141   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99142   if (!arg2) {
99143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99144     return 0;
99145   }
99146   {
99147     try {
99148       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99149     } catch (std::out_of_range& e) {
99150       {
99151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99152       };
99153     } catch (std::exception& e) {
99154       {
99155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99156       };
99157     } catch (Dali::DaliException e) {
99158       {
99159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99160       };
99161     } catch (...) {
99162       {
99163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99164       };
99165     }
99166   }
99167
99168   jresult = (void *)result;
99169   return jresult;
99170 }
99171
99172
99173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99174   void * jresult ;
99175   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99176   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99177   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99178
99179   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99180   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99181   {
99182     try {
99183       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99184     } catch (std::out_of_range& e) {
99185       {
99186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99187       };
99188     } catch (std::exception& e) {
99189       {
99190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99191       };
99192     } catch (Dali::DaliException e) {
99193       {
99194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99195       };
99196     } catch (...) {
99197       {
99198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99199       };
99200     }
99201   }
99202
99203   jresult = (void *)result;
99204   return jresult;
99205 }
99206
99207
99208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99209   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99210
99211   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99212   {
99213     try {
99214       (arg1)->Reset();
99215     } catch (std::out_of_range& e) {
99216       {
99217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99218       };
99219     } catch (std::exception& e) {
99220       {
99221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99222       };
99223     } catch (Dali::DaliException e) {
99224       {
99225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99226       };
99227     } catch (...) {
99228       {
99229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99230       };
99231     }
99232   }
99233
99234 }
99235
99236
99237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99238   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99239   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99240
99241   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99242   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99243   {
99244     try {
99245       (arg1)->Reset(arg2);
99246     } catch (std::out_of_range& e) {
99247       {
99248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99249       };
99250     } catch (std::exception& e) {
99251       {
99252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99253       };
99254     } catch (Dali::DaliException e) {
99255       {
99256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99257       };
99258     } catch (...) {
99259       {
99260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99261       };
99262     }
99263   }
99264
99265 }
99266
99267
99268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99269   void * jresult ;
99270   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99271   Dali::Toolkit::Ruler *result = 0 ;
99272
99273   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99274   {
99275     try {
99276       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99277     } catch (std::out_of_range& e) {
99278       {
99279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99280       };
99281     } catch (std::exception& e) {
99282       {
99283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99284       };
99285     } catch (Dali::DaliException e) {
99286       {
99287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99288       };
99289     } catch (...) {
99290       {
99291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99292       };
99293     }
99294   }
99295
99296   jresult = (void *)result;
99297   return jresult;
99298 }
99299
99300
99301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99302   float jresult ;
99303   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99304   float arg2 ;
99305   float arg3 ;
99306   float result;
99307
99308   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99309   arg2 = (float)jarg2;
99310   arg3 = (float)jarg3;
99311   {
99312     try {
99313       result = (float)(*arg1)->Snap(arg2,arg3);
99314     } catch (std::out_of_range& e) {
99315       {
99316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99317       };
99318     } catch (std::exception& e) {
99319       {
99320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99321       };
99322     } catch (Dali::DaliException e) {
99323       {
99324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99325       };
99326     } catch (...) {
99327       {
99328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99329       };
99330     }
99331   }
99332
99333   jresult = result;
99334   return jresult;
99335 }
99336
99337
99338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99339   float jresult ;
99340   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99341   float arg2 ;
99342   float result;
99343
99344   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99345   arg2 = (float)jarg2;
99346   {
99347     try {
99348       result = (float)(*arg1)->Snap(arg2);
99349     } catch (std::out_of_range& e) {
99350       {
99351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99352       };
99353     } catch (std::exception& e) {
99354       {
99355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99356       };
99357     } catch (Dali::DaliException e) {
99358       {
99359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99360       };
99361     } catch (...) {
99362       {
99363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99364       };
99365     }
99366   }
99367
99368   jresult = result;
99369   return jresult;
99370 }
99371
99372
99373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99374   float jresult ;
99375   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99376   unsigned int arg2 ;
99377   unsigned int *arg3 = 0 ;
99378   bool arg4 ;
99379   float result;
99380
99381   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99382   arg2 = (unsigned int)jarg2;
99383   arg3 = (unsigned int *)jarg3;
99384   arg4 = jarg4 ? true : false;
99385   {
99386     try {
99387       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99388     } catch (std::out_of_range& e) {
99389       {
99390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99391       };
99392     } catch (std::exception& e) {
99393       {
99394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99395       };
99396     } catch (Dali::DaliException e) {
99397       {
99398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99399       };
99400     } catch (...) {
99401       {
99402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99403       };
99404     }
99405   }
99406
99407   jresult = result;
99408   return jresult;
99409 }
99410
99411
99412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99413   unsigned int jresult ;
99414   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99415   float arg2 ;
99416   bool arg3 ;
99417   unsigned int result;
99418
99419   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99420   arg2 = (float)jarg2;
99421   arg3 = jarg3 ? true : false;
99422   {
99423     try {
99424       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99425     } catch (std::out_of_range& e) {
99426       {
99427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99428       };
99429     } catch (std::exception& e) {
99430       {
99431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99432       };
99433     } catch (Dali::DaliException e) {
99434       {
99435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99436       };
99437     } catch (...) {
99438       {
99439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99440       };
99441     }
99442   }
99443
99444   jresult = result;
99445   return jresult;
99446 }
99447
99448
99449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99450   unsigned int jresult ;
99451   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99452   unsigned int result;
99453
99454   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99455   {
99456     try {
99457       result = (unsigned int)(*arg1)->GetTotalPages();
99458     } catch (std::out_of_range& e) {
99459       {
99460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99461       };
99462     } catch (std::exception& e) {
99463       {
99464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99465       };
99466     } catch (Dali::DaliException e) {
99467       {
99468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99469       };
99470     } catch (...) {
99471       {
99472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99473       };
99474     }
99475   }
99476
99477   jresult = result;
99478   return jresult;
99479 }
99480
99481
99482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99483   int jresult ;
99484   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99485   Dali::Toolkit::Ruler::RulerType result;
99486
99487   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99488   {
99489     try {
99490       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99491     } catch (std::out_of_range& e) {
99492       {
99493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99494       };
99495     } catch (std::exception& e) {
99496       {
99497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99498       };
99499     } catch (Dali::DaliException e) {
99500       {
99501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99502       };
99503     } catch (...) {
99504       {
99505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99506       };
99507     }
99508   }
99509
99510   jresult = (int)result;
99511   return jresult;
99512 }
99513
99514
99515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99516   unsigned int jresult ;
99517   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99518   bool result;
99519
99520   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99521   {
99522     try {
99523       result = (bool)(*arg1)->IsEnabled();
99524     } catch (std::out_of_range& e) {
99525       {
99526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99527       };
99528     } catch (std::exception& e) {
99529       {
99530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99531       };
99532     } catch (Dali::DaliException e) {
99533       {
99534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99535       };
99536     } catch (...) {
99537       {
99538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99539       };
99540     }
99541   }
99542
99543   jresult = result;
99544   return jresult;
99545 }
99546
99547
99548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99549   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99550
99551   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99552   {
99553     try {
99554       (*arg1)->Enable();
99555     } catch (std::out_of_range& e) {
99556       {
99557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99558       };
99559     } catch (std::exception& e) {
99560       {
99561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99562       };
99563     } catch (Dali::DaliException e) {
99564       {
99565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99566       };
99567     } catch (...) {
99568       {
99569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99570       };
99571     }
99572   }
99573
99574 }
99575
99576
99577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99578   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99579
99580   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99581   {
99582     try {
99583       (*arg1)->Disable();
99584     } catch (std::out_of_range& e) {
99585       {
99586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99587       };
99588     } catch (std::exception& e) {
99589       {
99590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99591       };
99592     } catch (Dali::DaliException e) {
99593       {
99594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99595       };
99596     } catch (...) {
99597       {
99598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99599       };
99600     }
99601   }
99602
99603 }
99604
99605
99606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99607   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99608   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99609   Dali::Toolkit::RulerDomain *argp2 ;
99610
99611   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99612   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99613   if (!argp2) {
99614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99615     return ;
99616   }
99617   arg2 = *argp2;
99618   {
99619     try {
99620       (*arg1)->SetDomain(arg2);
99621     } catch (std::out_of_range& e) {
99622       {
99623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99624       };
99625     } catch (std::exception& e) {
99626       {
99627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99628       };
99629     } catch (Dali::DaliException e) {
99630       {
99631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99632       };
99633     } catch (...) {
99634       {
99635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99636       };
99637     }
99638   }
99639
99640 }
99641
99642
99643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99644   void * jresult ;
99645   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99646   Dali::Toolkit::RulerDomain *result = 0 ;
99647
99648   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99649   {
99650     try {
99651       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99652     } catch (std::out_of_range& e) {
99653       {
99654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99655       };
99656     } catch (std::exception& e) {
99657       {
99658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99659       };
99660     } catch (Dali::DaliException e) {
99661       {
99662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99663       };
99664     } catch (...) {
99665       {
99666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99667       };
99668     }
99669   }
99670
99671   jresult = (void *)result;
99672   return jresult;
99673 }
99674
99675
99676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99677   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99678
99679   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99680   {
99681     try {
99682       (*arg1)->DisableDomain();
99683     } catch (std::out_of_range& e) {
99684       {
99685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99686       };
99687     } catch (std::exception& e) {
99688       {
99689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99690       };
99691     } catch (Dali::DaliException e) {
99692       {
99693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99694       };
99695     } catch (...) {
99696       {
99697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99698       };
99699     }
99700   }
99701
99702 }
99703
99704
99705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99706   float jresult ;
99707   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99708   float arg2 ;
99709   float arg3 ;
99710   float arg4 ;
99711   float result;
99712
99713   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99714   arg2 = (float)jarg2;
99715   arg3 = (float)jarg3;
99716   arg4 = (float)jarg4;
99717   {
99718     try {
99719       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99720     } catch (std::out_of_range& e) {
99721       {
99722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99723       };
99724     } catch (std::exception& e) {
99725       {
99726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99727       };
99728     } catch (Dali::DaliException e) {
99729       {
99730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99731       };
99732     } catch (...) {
99733       {
99734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99735       };
99736     }
99737   }
99738
99739   jresult = result;
99740   return jresult;
99741 }
99742
99743
99744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99745   float jresult ;
99746   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99747   float arg2 ;
99748   float arg3 ;
99749   float result;
99750
99751   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99752   arg2 = (float)jarg2;
99753   arg3 = (float)jarg3;
99754   {
99755     try {
99756       result = (float)(*arg1)->Clamp(arg2,arg3);
99757     } catch (std::out_of_range& e) {
99758       {
99759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99760       };
99761     } catch (std::exception& e) {
99762       {
99763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99764       };
99765     } catch (Dali::DaliException e) {
99766       {
99767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99768       };
99769     } catch (...) {
99770       {
99771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99772       };
99773     }
99774   }
99775
99776   jresult = result;
99777   return jresult;
99778 }
99779
99780
99781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99782   float jresult ;
99783   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99784   float arg2 ;
99785   float result;
99786
99787   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99788   arg2 = (float)jarg2;
99789   {
99790     try {
99791       result = (float)(*arg1)->Clamp(arg2);
99792     } catch (std::out_of_range& e) {
99793       {
99794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99795       };
99796     } catch (std::exception& e) {
99797       {
99798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99799       };
99800     } catch (Dali::DaliException e) {
99801       {
99802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99803       };
99804     } catch (...) {
99805       {
99806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99807       };
99808     }
99809   }
99810
99811   jresult = result;
99812   return jresult;
99813 }
99814
99815
99816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99817   float jresult ;
99818   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99819   float arg2 ;
99820   float arg3 ;
99821   float arg4 ;
99822   Dali::Toolkit::ClampState *arg5 = 0 ;
99823   float result;
99824
99825   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99826   arg2 = (float)jarg2;
99827   arg3 = (float)jarg3;
99828   arg4 = (float)jarg4;
99829   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99830   if (!arg5) {
99831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99832     return 0;
99833   }
99834   {
99835     try {
99836       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99837     } catch (std::out_of_range& e) {
99838       {
99839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99840       };
99841     } catch (std::exception& e) {
99842       {
99843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99844       };
99845     } catch (Dali::DaliException e) {
99846       {
99847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99848       };
99849     } catch (...) {
99850       {
99851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99852       };
99853     }
99854   }
99855
99856   jresult = result;
99857   return jresult;
99858 }
99859
99860
99861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99862   float jresult ;
99863   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99864   float arg2 ;
99865   float arg3 ;
99866   float arg4 ;
99867   float arg5 ;
99868   float result;
99869
99870   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99871   arg2 = (float)jarg2;
99872   arg3 = (float)jarg3;
99873   arg4 = (float)jarg4;
99874   arg5 = (float)jarg5;
99875   {
99876     try {
99877       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99878     } catch (std::out_of_range& e) {
99879       {
99880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99881       };
99882     } catch (std::exception& e) {
99883       {
99884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99885       };
99886     } catch (Dali::DaliException e) {
99887       {
99888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99889       };
99890     } catch (...) {
99891       {
99892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99893       };
99894     }
99895   }
99896
99897   jresult = result;
99898   return jresult;
99899 }
99900
99901
99902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99903   float jresult ;
99904   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99905   float arg2 ;
99906   float arg3 ;
99907   float arg4 ;
99908   float result;
99909
99910   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99911   arg2 = (float)jarg2;
99912   arg3 = (float)jarg3;
99913   arg4 = (float)jarg4;
99914   {
99915     try {
99916       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99917     } catch (std::out_of_range& e) {
99918       {
99919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99920       };
99921     } catch (std::exception& e) {
99922       {
99923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99924       };
99925     } catch (Dali::DaliException e) {
99926       {
99927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99928       };
99929     } catch (...) {
99930       {
99931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99932       };
99933     }
99934   }
99935
99936   jresult = result;
99937   return jresult;
99938 }
99939
99940
99941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99942   float jresult ;
99943   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99944   float arg2 ;
99945   float arg3 ;
99946   float result;
99947
99948   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99949   arg2 = (float)jarg2;
99950   arg3 = (float)jarg3;
99951   {
99952     try {
99953       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99954     } catch (std::out_of_range& e) {
99955       {
99956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99957       };
99958     } catch (std::exception& e) {
99959       {
99960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99961       };
99962     } catch (Dali::DaliException e) {
99963       {
99964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99965       };
99966     } catch (...) {
99967       {
99968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99969       };
99970     }
99971   }
99972
99973   jresult = result;
99974   return jresult;
99975 }
99976
99977
99978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99979   float jresult ;
99980   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99981   float arg2 ;
99982   float result;
99983
99984   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99985   arg2 = (float)jarg2;
99986   {
99987     try {
99988       result = (float)(*arg1)->SnapAndClamp(arg2);
99989     } catch (std::out_of_range& e) {
99990       {
99991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99992       };
99993     } catch (std::exception& e) {
99994       {
99995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99996       };
99997     } catch (Dali::DaliException e) {
99998       {
99999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100000       };
100001     } catch (...) {
100002       {
100003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100004       };
100005     }
100006   }
100007
100008   jresult = result;
100009   return jresult;
100010 }
100011
100012
100013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100014   float jresult ;
100015   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100016   float arg2 ;
100017   float arg3 ;
100018   float arg4 ;
100019   float arg5 ;
100020   Dali::Toolkit::ClampState *arg6 = 0 ;
100021   float result;
100022
100023   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100024   arg2 = (float)jarg2;
100025   arg3 = (float)jarg3;
100026   arg4 = (float)jarg4;
100027   arg5 = (float)jarg5;
100028   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100029   if (!arg6) {
100030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100031     return 0;
100032   }
100033   {
100034     try {
100035       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100036     } catch (std::out_of_range& e) {
100037       {
100038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100039       };
100040     } catch (std::exception& e) {
100041       {
100042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100043       };
100044     } catch (Dali::DaliException e) {
100045       {
100046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100047       };
100048     } catch (...) {
100049       {
100050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100051       };
100052     }
100053   }
100054
100055   jresult = result;
100056   return jresult;
100057 }
100058
100059
100060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100061   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100062
100063   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100064   {
100065     try {
100066       (*arg1)->Reference();
100067     } catch (std::out_of_range& e) {
100068       {
100069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100070       };
100071     } catch (std::exception& e) {
100072       {
100073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100074       };
100075     } catch (Dali::DaliException e) {
100076       {
100077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100078       };
100079     } catch (...) {
100080       {
100081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100082       };
100083     }
100084   }
100085
100086 }
100087
100088
100089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100090   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100091
100092   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100093   {
100094     try {
100095       (*arg1)->Unreference();
100096     } catch (std::out_of_range& e) {
100097       {
100098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100099       };
100100     } catch (std::exception& e) {
100101       {
100102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100103       };
100104     } catch (Dali::DaliException e) {
100105       {
100106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100107       };
100108     } catch (...) {
100109       {
100110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100111       };
100112     }
100113   }
100114
100115 }
100116
100117
100118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100119   int jresult ;
100120   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100121   int result;
100122
100123   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100124   {
100125     try {
100126       result = (int)(*arg1)->ReferenceCount();
100127     } catch (std::out_of_range& e) {
100128       {
100129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100130       };
100131     } catch (std::exception& e) {
100132       {
100133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100134       };
100135     } catch (Dali::DaliException e) {
100136       {
100137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100138       };
100139     } catch (...) {
100140       {
100141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100142       };
100143     }
100144   }
100145
100146   jresult = result;
100147   return jresult;
100148 }
100149
100150
100151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100152   unsigned int jresult ;
100153   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100154   bool result;
100155
100156   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100157   {
100158     try {
100159       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100160     } catch (std::out_of_range& e) {
100161       {
100162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100163       };
100164     } catch (std::exception& e) {
100165       {
100166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100167       };
100168     } catch (Dali::DaliException e) {
100169       {
100170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100171       };
100172     } catch (...) {
100173       {
100174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100175       };
100176     }
100177   }
100178
100179   jresult = result;
100180   return jresult;
100181 }
100182
100183
100184 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100185   unsigned long jresult ;
100186   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100187   std::size_t result;
100188
100189   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100190   {
100191     try {
100192       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100193     } catch (std::out_of_range& e) {
100194       {
100195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100196       };
100197     } catch (std::exception& e) {
100198       {
100199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100200       };
100201     } catch (Dali::DaliException e) {
100202       {
100203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100204       };
100205     } catch (...) {
100206       {
100207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100208       };
100209     }
100210   }
100211
100212   jresult = (unsigned long)result;
100213   return jresult;
100214 }
100215
100216
100217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100218   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100219   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100220
100221   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100222   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100223   {
100224     try {
100225       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100226     } catch (std::out_of_range& e) {
100227       {
100228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100229       };
100230     } catch (std::exception& e) {
100231       {
100232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100233       };
100234     } catch (Dali::DaliException e) {
100235       {
100236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100237       };
100238     } catch (...) {
100239       {
100240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100241       };
100242     }
100243   }
100244
100245 }
100246
100247
100248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100249   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100250   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100251
100252   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100253   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100254   {
100255     try {
100256       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100257     } catch (std::out_of_range& e) {
100258       {
100259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100260       };
100261     } catch (std::exception& e) {
100262       {
100263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100264       };
100265     } catch (Dali::DaliException e) {
100266       {
100267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100268       };
100269     } catch (...) {
100270       {
100271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100272       };
100273     }
100274   }
100275
100276 }
100277
100278
100279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100280   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100281   Dali::Toolkit::Control arg2 ;
100282   Dali::Toolkit::Control *argp2 ;
100283
100284   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100285   argp2 = (Dali::Toolkit::Control *)jarg2;
100286   if (!argp2) {
100287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100288     return ;
100289   }
100290   arg2 = *argp2;
100291   {
100292     try {
100293       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100294     } catch (std::out_of_range& e) {
100295       {
100296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100297       };
100298     } catch (std::exception& e) {
100299       {
100300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100301       };
100302     } catch (Dali::DaliException e) {
100303       {
100304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100305       };
100306     } catch (...) {
100307       {
100308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100309       };
100310     }
100311   }
100312
100313 }
100314
100315
100316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100317   void * jresult ;
100318   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100319
100320   {
100321     try {
100322       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100323     } catch (std::out_of_range& e) {
100324       {
100325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100326       };
100327     } catch (std::exception& e) {
100328       {
100329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100330       };
100331     } catch (Dali::DaliException e) {
100332       {
100333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100334       };
100335     } catch (...) {
100336       {
100337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100338       };
100339     }
100340   }
100341
100342   jresult = (void *)result;
100343   return jresult;
100344 }
100345
100346
100347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100348   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100349
100350   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100351   {
100352     try {
100353       delete arg1;
100354     } catch (std::out_of_range& e) {
100355       {
100356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100357       };
100358     } catch (std::exception& e) {
100359       {
100360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100361       };
100362     } catch (Dali::DaliException e) {
100363       {
100364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100365       };
100366     } catch (...) {
100367       {
100368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100369       };
100370     }
100371   }
100372
100373 }
100374
100375 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100376   Dali::RefObject *result = NULL;
100377
100378   if (arg1)
100379   {
100380     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100381   }
100382   return result;
100383 }
100384
100385 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100386     return (Dali::RefObject *)jarg1;
100387 }
100388
100389 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100390     return (Dali::SignalObserver *)jarg1;
100391 }
100392
100393 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100394     return (Dali::ConnectionTrackerInterface *)jarg1;
100395 }
100396
100397 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100398     return (Dali::BaseHandle *)jarg1;
100399 }
100400
100401 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100402     return (Dali::BaseHandle *)jarg1;
100403 }
100404
100405 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100406     return (Dali::BaseHandle *)jarg1;
100407 }
100408
100409 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100410     return (Dali::BaseHandle *)jarg1;
100411 }
100412
100413 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100414     return (Dali::BaseHandle *)jarg1;
100415 }
100416
100417 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100418     return (Dali::BaseHandle *)jarg1;
100419 }
100420
100421 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100422     return (Dali::BaseHandle *)jarg1;
100423 }
100424
100425 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100426     return (Dali::BaseHandle *)jarg1;
100427 }
100428
100429 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100430     return (Dali::BaseHandle *)jarg1;
100431 }
100432
100433 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100434     return (Dali::BaseHandle *)jarg1;
100435 }
100436
100437 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100438     return (Dali::BaseHandle *)jarg1;
100439 }
100440
100441 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100442     return (Dali::BaseHandle *)jarg1;
100443 }
100444
100445 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100446     return (Dali::BaseHandle *)jarg1;
100447 }
100448
100449 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100450     return (Dali::Handle *)jarg1;
100451 }
100452
100453 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100454     return (Dali::Handle *)jarg1;
100455 }
100456
100457 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100458     return (Dali::BaseHandle *)jarg1;
100459 }
100460
100461 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100462     return (Dali::BaseHandle *)jarg1;
100463 }
100464
100465 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100466     return (Dali::Handle *)jarg1;
100467 }
100468
100469 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100470     return (Dali::BaseHandle *)jarg1;
100471 }
100472
100473 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100474     return (Dali::Handle *)jarg1;
100475 }
100476
100477 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100478     return (Dali::GestureDetector *)jarg1;
100479 }
100480
100481 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100482     return (Dali::Gesture *)jarg1;
100483 }
100484
100485 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100486     return (Dali::Handle *)jarg1;
100487 }
100488
100489 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100490     return (Dali::Actor *)jarg1;
100491 }
100492
100493 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100494     return (Dali::BaseHandle *)jarg1;
100495 }
100496
100497 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100498     return (Dali::RefObject *)jarg1;
100499 }
100500
100501 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100502     return (Dali::Actor *)jarg1;
100503 }
100504
100505 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100506     return (Dali::GestureDetector *)jarg1;
100507 }
100508
100509 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100510     return (Dali::Gesture *)jarg1;
100511 }
100512
100513 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100514     return (Dali::GestureDetector *)jarg1;
100515 }
100516
100517 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100518     return (Dali::Gesture *)jarg1;
100519 }
100520
100521 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100522     return (Dali::GestureDetector *)jarg1;
100523 }
100524
100525 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100526     return (Dali::Gesture *)jarg1;
100527 }
100528
100529 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100530     return (Dali::BaseHandle *)jarg1;
100531 }
100532
100533 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100534     return (Dali::Handle *)jarg1;
100535 }
100536
100537 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100538     return (Dali::Handle *)jarg1;
100539 }
100540
100541 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100542     return (Dali::Handle *)jarg1;
100543 }
100544
100545 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100546     return (Dali::Image *)jarg1;
100547 }
100548
100549 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100550     return (Dali::Image *)jarg1;
100551 }
100552
100553 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100554     return (Dali::Image *)jarg1;
100555 }
100556
100557 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100558     return (Dali::RefObject *)jarg1;
100559 }
100560
100561 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100562     return (Dali::Image *)jarg1;
100563 }
100564
100565 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100566     return (Dali::Image *)jarg1;
100567 }
100568
100569 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100570     return (Dali::ResourceImage *)jarg1;
100571 }
100572
100573 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100574     return (Dali::Actor *)jarg1;
100575 }
100576
100577 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100578     return (Dali::BaseHandle *)jarg1;
100579 }
100580
100581 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100582     return (Dali::BaseHandle *)jarg1;
100583 }
100584
100585 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100586     return (Dali::BaseHandle *)jarg1;
100587 }
100588
100589 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100590     return (Dali::CustomActorImpl *)jarg1;
100591 }
100592
100593 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100594     return (Dali::CustomActor *)jarg1;
100595 }
100596
100597 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100598     return (Dali::BaseHandle *)jarg1;
100599 }
100600
100601 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100602     return (Dali::Toolkit::Control *)jarg1;
100603 }
100604
100605 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100606     return (Dali::Toolkit::Control *)jarg1;
100607 }
100608
100609 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100610     return (Dali::Toolkit::Button *)jarg1;
100611 }
100612
100613 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100614     return (Dali::Toolkit::Button *)jarg1;
100615 }
100616
100617 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100618     return (Dali::Toolkit::Button *)jarg1;
100619 }
100620
100621 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100622     return (Dali::Toolkit::Control *)jarg1;
100623 }
100624
100625 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100626     return (Dali::Toolkit::Control *)jarg1;
100627 }
100628
100629 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100630     return (Dali::Toolkit::Control *)jarg1;
100631 }
100632
100633 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100634     return (Dali::Toolkit::Control *)jarg1;
100635 }
100636
100637 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100638     return (Dali::Toolkit::Control *)jarg1;
100639 }
100640
100641 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100642     return (Dali::RefObject *)jarg1;
100643 }
100644
100645 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100646     return (Dali::Toolkit::Scrollable *)jarg1;
100647 }
100648
100649 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100650     return (Dali::BaseHandle *)jarg1;
100651 }
100652
100653 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100654     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100655 }
100656
100657 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100658     return (Dali::RefObject *)jarg1;
100659 }
100660
100661 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100662     return (Dali::Toolkit::Ruler *)jarg1;
100663 }
100664
100665 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100666     return (Dali::Toolkit::Ruler *)jarg1;
100667 }
100668
100669 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100670     return (Dali::Toolkit::Scrollable *)jarg1;
100671 }
100672
100673 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100674     return (Dali::Toolkit::Control *)jarg1;
100675 }
100676
100677
100678 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100679     return (Dali::Toolkit::Control *)jarg1;
100680 }
100681
100682 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100683     return (Dali::BaseHandle *)jarg1;
100684 }
100685
100686 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100687     return (Dali::BaseHandle *)jarg1;
100688 }
100689
100690 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100691     return (Dali::Toolkit::Control *)jarg1;
100692 }
100693
100694 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100695     return (Dali::Toolkit::Control *)jarg1;
100696 }
100697
100698 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100699     return (Dali::Toolkit::Control *)jarg1;
100700 }
100701
100702 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100703     return (Dali::Toolkit::Control *)jarg1;
100704 }
100705
100706 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100707     return (Dali::Toolkit::Control *)jarg1;
100708 }
100709
100710 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100711     return (Dali::Toolkit::Control *)jarg1;
100712 }
100713
100714 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100715     return (Dali::Toolkit::PageTurnView *)jarg1;
100716 }
100717
100718 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100719     return (Dali::Toolkit::PageTurnView *)jarg1;
100720 }
100721
100722 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100723     return (Dali::Toolkit::Button *)jarg1;
100724 }
100725
100726 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100727     return (Dali::BaseHandle *)jarg1;
100728 }
100729
100730 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100731     return (Dali::BaseHandle *)jarg1;
100732 }
100733
100734 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100735     return (Dali::BaseHandle *)jarg1;
100736 }
100737
100738 /*
100739  * Widget binding
100740  */
100741 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100742     return (Dali::BaseHandle *)jarg1;
100743 }
100744
100745 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100746     return (Dali::BaseObject *)jarg1;
100747 }
100748
100749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100750   void * jresult ;
100751   Dali::Widget result;
100752
100753   {
100754     try {
100755       result = Dali::Widget::New();
100756     } catch (std::out_of_range& e) {
100757       {
100758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100759       };
100760     } catch (std::exception& e) {
100761       {
100762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100763       };
100764     } catch (...) {
100765       {
100766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100767       };
100768     }
100769   }
100770   jresult = new Dali::Widget((const Dali::Widget &)result);
100771   return jresult;
100772 }
100773
100774
100775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100776   void * jresult ;
100777   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100778   Dali::Widget result;
100779
100780   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100781
100782   if (!arg1) {
100783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100784     return 0;
100785   }
100786   {
100787     try {
100788       jresult = new Dali::Widget(arg1);
100789     } catch (std::out_of_range& e) {
100790       {
100791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100792       };
100793     } catch (std::exception& e) {
100794       {
100795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100796       };
100797     } catch (...) {
100798       {
100799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100800       };
100801     }
100802   }
100803   return jresult;
100804 }
100805
100806
100807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100808   void * jresult ;
100809   Dali::Widget *result = 0 ;
100810
100811   {
100812     try {
100813       result = (Dali::Widget *)new Dali::Widget();
100814     } catch (std::out_of_range& e) {
100815       {
100816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100817       };
100818     } catch (std::exception& e) {
100819       {
100820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100821       };
100822     } catch (...) {
100823       {
100824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100825       };
100826     }
100827   }
100828   jresult = (void *)result;
100829   return jresult;
100830 }
100831
100832
100833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100834   void * jresult ;
100835   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100836   Dali::Widget *arg2 = 0 ;
100837   Dali::Widget *result = 0 ;
100838
100839   arg1 = (Dali::Widget *)jarg1;
100840   arg2 = (Dali::Widget *)jarg2;
100841   if (!arg2) {
100842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100843     return 0;
100844   }
100845   {
100846     try {
100847       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100848     } catch (std::out_of_range& e) {
100849       {
100850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100851       };
100852     } catch (std::exception& e) {
100853       {
100854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100855       };
100856     } catch (...) {
100857       {
100858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100859       };
100860     }
100861   }
100862   jresult = (void *)result;
100863   return jresult;
100864 }
100865
100866
100867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100868   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100869
100870   arg1 = (Dali::Widget *)jarg1;
100871   {
100872     try {
100873       delete arg1;
100874     } catch (std::out_of_range& e) {
100875       {
100876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100877       };
100878     } catch (std::exception& e) {
100879       {
100880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100881       };
100882     } catch (...) {
100883       {
100884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100885       };
100886     }
100887   }
100888 }
100889
100890
100891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100892   void * jresult ;
100893   SwigDirector_WidgetImpl* result;
100894   {
100895     try {
100896       result = new SwigDirector_WidgetImpl();
100897     } catch (std::out_of_range& e) {
100898       {
100899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100900       };
100901     } catch (std::exception& e) {
100902       {
100903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100904       };
100905     } catch (...) {
100906       {
100907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100908       };
100909     }
100910   }
100911   jresult = result;
100912   return jresult;
100913 }
100914
100915
100916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100917   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100918   std::string *arg2 = 0 ;
100919   Dali::Window arg3 ;
100920   Dali::Window *argp3 ;
100921
100922   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100923   if (!jarg2) {
100924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100925     return ;
100926   }
100927   std::string arg2_str(jarg2);
100928   arg2 = &arg2_str;
100929   argp3 = (Dali::Window *)jarg3;
100930   if (!argp3) {
100931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100932     return ;
100933   }
100934   arg3 = *argp3;
100935   {
100936     try {
100937       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100938     } catch (std::out_of_range& e) {
100939       {
100940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100941       };
100942     } catch (std::exception& e) {
100943       {
100944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100945       };
100946     } catch (...) {
100947       {
100948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100949       };
100950     }
100951   }
100952 }
100953
100954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100955   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100956   std::string *arg2 = 0 ;
100957   Dali::Window arg3 ;
100958   Dali::Window *argp3 ;
100959
100960   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100961   if (!jarg2) {
100962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100963     return ;
100964   }
100965   std::string arg2_str(jarg2);
100966   arg2 = &arg2_str;
100967   argp3 = (Dali::Window *)jarg3;
100968   if (!argp3) {
100969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100970     return ;
100971   }
100972   arg3 = *argp3;
100973   {
100974     try {
100975       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100976     } catch (std::out_of_range& e) {
100977       {
100978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100979       };
100980     } catch (std::exception& e) {
100981       {
100982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100983       };
100984     } catch (...) {
100985       {
100986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100987       };
100988     }
100989   }
100990 }
100991
100992
100993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100994   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100995   std::string *arg2 = 0 ;
100996   Dali::Widget::Termination arg3 ;
100997
100998   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100999   if (!jarg2) {
101000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101001     return ;
101002   }
101003   std::string arg2_str(jarg2);
101004   arg2 = &arg2_str;
101005   arg3 = (Dali::Widget::Termination)jarg3;
101006   {
101007     try {
101008       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101009     } catch (std::out_of_range& e) {
101010       {
101011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101012       };
101013     } catch (std::exception& e) {
101014       {
101015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101016       };
101017     } catch (...) {
101018       {
101019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101020       };
101021     }
101022   }
101023 }
101024
101025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101026   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101027   std::string *arg2 = 0 ;
101028   Dali::Widget::Termination arg3 ;
101029
101030   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101031   if (!jarg2) {
101032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101033     return ;
101034   }
101035   std::string arg2_str(jarg2);
101036   arg2 = &arg2_str;
101037   arg3 = (Dali::Widget::Termination)jarg3;
101038   {
101039     try {
101040       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101041     } catch (std::out_of_range& e) {
101042       {
101043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101044       };
101045     } catch (std::exception& e) {
101046       {
101047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101048       };
101049     } catch (...) {
101050       {
101051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101052       };
101053     }
101054   }
101055 }
101056
101057
101058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101059   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101060
101061   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101062   {
101063     try {
101064       (arg1)->OnPause();
101065     } catch (std::out_of_range& e) {
101066       {
101067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101068       };
101069     } catch (std::exception& e) {
101070       {
101071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101072       };
101073     } catch (...) {
101074       {
101075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101076       };
101077     }
101078   }
101079 }
101080
101081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101082   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101083
101084   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101085   {
101086     try {
101087       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101088     } catch (std::out_of_range& e) {
101089       {
101090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101091       };
101092     } catch (std::exception& e) {
101093       {
101094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101095       };
101096     } catch (...) {
101097       {
101098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101099       };
101100     }
101101   }
101102 }
101103
101104
101105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101106   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101107
101108   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101109   {
101110     try {
101111       (arg1)->OnResume();
101112     } catch (std::out_of_range& e) {
101113       {
101114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101115       };
101116     } catch (std::exception& e) {
101117       {
101118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101119       };
101120     } catch (...) {
101121       {
101122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101123       };
101124     }
101125   }
101126 }
101127
101128
101129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101130   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101131
101132   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101133   {
101134     try {
101135       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101136     } catch (std::out_of_range& e) {
101137       {
101138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101139       };
101140     } catch (std::exception& e) {
101141       {
101142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101143       };
101144     } catch (...) {
101145       {
101146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101147       };
101148     }
101149   }
101150 }
101151
101152
101153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101154   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101155   Dali::Window arg2 ;
101156   Dali::Window *argp2 ;
101157
101158   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101159   argp2 = (Dali::Window *)jarg2;
101160   if (!argp2) {
101161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101162     return ;
101163   }
101164   arg2 = *argp2;
101165   {
101166     try {
101167       (arg1)->OnResize(arg2);
101168     } catch (std::out_of_range& e) {
101169       {
101170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101171       };
101172     } catch (std::exception& e) {
101173       {
101174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101175       };
101176     } catch (...) {
101177       {
101178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101179       };
101180     }
101181   }
101182 }
101183
101184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101185   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101186   Dali::Window arg2 ;
101187   Dali::Window *argp2 ;
101188
101189   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101190   argp2 = (Dali::Window *)jarg2;
101191   if (!argp2) {
101192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101193     return ;
101194   }
101195   arg2 = *argp2;
101196   {
101197     try {
101198       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101199     } catch (std::out_of_range& e) {
101200       {
101201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101202       };
101203     } catch (std::exception& e) {
101204       {
101205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101206       };
101207     } catch (...) {
101208       {
101209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101210       };
101211     }
101212   }
101213 }
101214
101215
101216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101217   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101218   std::string *arg2 = 0 ;
101219   int arg3 ;
101220
101221   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101222   if (!jarg2) {
101223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101224     return ;
101225   }
101226   std::string arg2_str(jarg2);
101227   arg2 = &arg2_str;
101228   arg3 = (int)jarg3;
101229   {
101230     try {
101231       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101232     } catch (std::out_of_range& e) {
101233       {
101234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101235       };
101236     } catch (std::exception& e) {
101237       {
101238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101239       };
101240     } catch (...) {
101241       {
101242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101243       };
101244     }
101245   }
101246 }
101247
101248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101249   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101250   std::string *arg2 = 0 ;
101251   int arg3 ;
101252
101253   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101254   if (!jarg2) {
101255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101256     return ;
101257   }
101258   std::string arg2_str(jarg2);
101259   arg2 = &arg2_str;
101260   arg3 = (int)jarg3;
101261   {
101262     try {
101263       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101264     } catch (std::out_of_range& e) {
101265       {
101266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101267       };
101268     } catch (std::exception& e) {
101269       {
101270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101271       };
101272     } catch (...) {
101273       {
101274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101275       };
101276     }
101277   }
101278 }
101279
101280
101281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101282   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101283   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101284   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101285
101286   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101287   arg2 = (Dali::SlotObserver *)jarg2;
101288   arg3 = (Dali::CallbackBase *)jarg3;
101289   {
101290     try {
101291       (arg1)->SignalConnected(arg2,arg3);
101292     } catch (std::out_of_range& e) {
101293       {
101294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101295       };
101296     } catch (std::exception& e) {
101297       {
101298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101299       };
101300     } catch (...) {
101301       {
101302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101303       };
101304     }
101305   }
101306 }
101307
101308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101309   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101310   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101311   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101312
101313   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101314   arg2 = (Dali::SlotObserver *)jarg2;
101315   arg3 = (Dali::CallbackBase *)jarg3;
101316   {
101317     try {
101318       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101319     } catch (std::out_of_range& e) {
101320       {
101321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101322       };
101323     } catch (std::exception& e) {
101324       {
101325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101326       };
101327     } catch (...) {
101328       {
101329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101330       };
101331     }
101332   }
101333 }
101334
101335
101336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101337   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101338   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101339   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101340
101341   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101342   arg2 = (Dali::SlotObserver *)jarg2;
101343   arg3 = (Dali::CallbackBase *)jarg3;
101344   {
101345     try {
101346       (arg1)->SignalDisconnected(arg2,arg3);
101347     } catch (std::out_of_range& e) {
101348       {
101349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101350       };
101351     } catch (std::exception& e) {
101352       {
101353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101354       };
101355     } catch (...) {
101356       {
101357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101358       };
101359     }
101360   }
101361 }
101362
101363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101364   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101365   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101366   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101367
101368   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101369   arg2 = (Dali::SlotObserver *)jarg2;
101370   arg3 = (Dali::CallbackBase *)jarg3;
101371   {
101372     try {
101373       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101374     } catch (std::out_of_range& e) {
101375       {
101376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101377       };
101378     } catch (std::exception& e) {
101379       {
101380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101381       };
101382     } catch (...) {
101383       {
101384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101385       };
101386     }
101387   }
101388 }
101389
101390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101391   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101392   std::string *arg2 = 0 ;
101393
101394   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101395   if (!jarg2) {
101396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101397     return ;
101398   }
101399   std::string arg2_str(jarg2);
101400   arg2 = &arg2_str;
101401   {
101402     try {
101403       (arg1)->SetContentInfo((std::string const &)*arg2);
101404     } catch (std::out_of_range& e) {
101405       {
101406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101407       };
101408     } catch (std::exception& e) {
101409       {
101410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101411       };
101412     } catch (...) {
101413       {
101414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101415       };
101416     }
101417   }
101418 }
101419
101420
101421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101422   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101423   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101424
101425   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101426   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101427   {
101428     try {
101429       (arg1)->SetImpl(arg2);
101430     } catch (std::out_of_range& e) {
101431       {
101432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101433       };
101434     } catch (std::exception& e) {
101435       {
101436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101437       };
101438     } catch (...) {
101439       {
101440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101441       };
101442     }
101443   }
101444 }
101445
101446 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) {
101447
101448   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101449   if (director) {
101450     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101451   }
101452 }
101453
101454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101455   void * jresult ;
101456   Dali::Widget *arg1 = 0 ;
101457   SwigDirector_WidgetImpl *result = 0 ;
101458
101459   arg1 = (Dali::Widget *)jarg1;
101460   if (!arg1) {
101461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101462     return 0;
101463   }
101464   {
101465     try {
101466       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101467     } catch (std::out_of_range& e) {
101468       {
101469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101470       };
101471     } catch (std::exception& e) {
101472       {
101473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101474       };
101475     } catch (...) {
101476       {
101477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101478       };
101479     }
101480   }
101481
101482   jresult = (void *)result;
101483   return jresult;
101484 }
101485
101486
101487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101488   void * jresult ;
101489   int *arg1 = (int *) 0 ;
101490   char ***arg2 ;
101491   std::string *arg3 = 0 ;
101492   Dali::WidgetApplication result;
101493   {
101494     int index = 0;
101495     int length = 0;
101496     char *retPtr;
101497     char *nextPtr;
101498     argWidgetC = jarg1;
101499     argWidgetV = new char*[jarg1 + 1];
101500
101501     retPtr = strtok_r( jarg2, " ", &nextPtr);
101502     if( retPtr )
101503     {
101504       length = strlen(retPtr);
101505     }
101506     argWidgetV[index] = new char[length + 1];
101507     if( retPtr )
101508     {
101509       strncpy(argWidgetV[index], retPtr, length);
101510     }
101511     argWidgetV[index][length] = '\0';
101512     index++;
101513
101514     while (index < jarg1)
101515     {
101516       length = 0;
101517       retPtr = strtok_r(NULL, " ", &nextPtr);
101518       if( retPtr )
101519       {
101520         length = strlen(retPtr);
101521       }
101522       argWidgetV[index] = new char[length + 1];
101523       if( retPtr )
101524       {
101525         strncpy(argWidgetV[index], retPtr, length);
101526       }
101527       argWidgetV[index][length] = '\0';
101528       index++;
101529     }
101530
101531     argWidgetV[jarg1] = NULL;
101532     argWidgetC = jarg1;
101533
101534     arg1 = &argWidgetC;
101535     arg2 = &argWidgetV;
101536   }
101537
101538   if (!jarg3) {
101539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101540     return 0;
101541   }
101542   std::string arg3_str(jarg3);
101543   arg3 = &arg3_str;
101544   {
101545     try {
101546       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101547     } catch (std::out_of_range& e) {
101548       {
101549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101550       };
101551     } catch (std::exception& e) {
101552       {
101553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101554       };
101555     } catch (...) {
101556       {
101557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101558       };
101559     }
101560   }
101561   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101562
101563   return jresult;
101564 }
101565
101566
101567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101568   void * jresult ;
101569   Dali::WidgetApplication *result = 0 ;
101570
101571   {
101572     try {
101573       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101574     } catch (std::out_of_range& e) {
101575       {
101576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101577       };
101578     } catch (std::exception& e) {
101579       {
101580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101581       };
101582     } catch (...) {
101583       {
101584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101585       };
101586     }
101587   }
101588   jresult = (void *)result;
101589   return jresult;
101590 }
101591
101592
101593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101594   void * jresult ;
101595   Dali::WidgetApplication *arg1 = 0 ;
101596   Dali::WidgetApplication *result = 0 ;
101597
101598   arg1 = (Dali::WidgetApplication *)jarg1;
101599   if (!arg1) {
101600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101601     return 0;
101602   }
101603   {
101604     try {
101605       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101606     } catch (std::out_of_range& e) {
101607       {
101608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101609       };
101610     } catch (std::exception& e) {
101611       {
101612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101613       };
101614     } catch (...) {
101615       {
101616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101617       };
101618     }
101619   }
101620   jresult = (void *)result;
101621   return jresult;
101622 }
101623
101624
101625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101626   void * jresult ;
101627   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101628   Dali::WidgetApplication *arg2 = 0 ;
101629   Dali::WidgetApplication *result = 0 ;
101630
101631   arg1 = (Dali::WidgetApplication *)jarg1;
101632   arg2 = (Dali::WidgetApplication *)jarg2;
101633   if (!arg2) {
101634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101635     return 0;
101636   }
101637   {
101638     try {
101639       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101640     } catch (std::out_of_range& e) {
101641       {
101642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101643       };
101644     } catch (std::exception& e) {
101645       {
101646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101647       };
101648     } catch (...) {
101649       {
101650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101651       };
101652     }
101653   }
101654   jresult = (void *)result;
101655   return jresult;
101656 }
101657
101658
101659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101660   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101661
101662   arg1 = (Dali::WidgetApplication *)jarg1;
101663   {
101664     try {
101665       delete arg1;
101666       if( argWidgetV )
101667       {
101668         // free string data
101669         for( int i=0; i < argWidgetC+1; i++)
101670         {
101671           delete [] argWidgetV[i];
101672         }
101673         delete [] argWidgetV;
101674       }
101675     } catch (std::out_of_range& e) {
101676       {
101677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101678       };
101679     } catch (std::exception& e) {
101680       {
101681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101682       };
101683     } catch (...) {
101684       {
101685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101686       };
101687     }
101688   }
101689 }
101690
101691
101692 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101693 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101694
101695 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101696 {
101697   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101698   return *widget;
101699 }
101700
101701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101702   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101703   std::string *arg2 = 0 ;
101704
101705   arg1 = (Dali::WidgetApplication *)jarg1;
101706   if (!jarg2) {
101707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101708     return ;
101709   }
101710   std::string arg2_str(*jarg2);
101711   arg2 = &arg2_str;
101712
101713   if(!_CSharpCreateWidgetFunction)
101714   {
101715     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101716   }
101717
101718   {
101719     try {
101720       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101721     } catch (std::out_of_range& e) {
101722       {
101723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101724       };
101725     } catch (std::exception& e) {
101726       {
101727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101728       };
101729     } catch (...) {
101730       {
101731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101732       };
101733     }
101734   }
101735
101736   //Typemap argout in c++ file.
101737   //This will convert c++ string to c# string
101738   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101739 }
101740
101741
101742 //for PixelBuffer and ImageLoading
101743
101744 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101745     return (Dali::BaseHandle *)jarg1;
101746 }
101747
101748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101749   void * jresult ;
101750   unsigned int arg1 ;
101751   unsigned int arg2 ;
101752   Dali::Pixel::Format arg3 ;
101753   Dali::Devel::PixelBuffer result;
101754
101755   arg1 = (unsigned int)jarg1;
101756   arg2 = (unsigned int)jarg2;
101757   arg3 = (Dali::Pixel::Format)jarg3;
101758   {
101759     try {
101760       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101761     } catch (std::out_of_range& e) {
101762       {
101763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101764       };
101765     } catch (std::exception& e) {
101766       {
101767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101768       };
101769     } catch (...) {
101770       {
101771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101772       };
101773     }
101774   }
101775   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101776   return jresult;
101777 }
101778
101779
101780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101781   void * jresult ;
101782   Dali::Devel::PixelBuffer *result = 0 ;
101783
101784   {
101785     try {
101786       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101787     } catch (std::out_of_range& e) {
101788       {
101789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101790       };
101791     } catch (std::exception& e) {
101792       {
101793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101794       };
101795     } catch (...) {
101796       {
101797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101798       };
101799     }
101800   }
101801   jresult = (void *)result;
101802   return jresult;
101803 }
101804
101805
101806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101807   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101808
101809   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101810   {
101811     try {
101812       delete arg1;
101813     } catch (std::out_of_range& e) {
101814       {
101815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101816       };
101817     } catch (std::exception& e) {
101818       {
101819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101820       };
101821     } catch (...) {
101822       {
101823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101824       };
101825     }
101826   }
101827 }
101828
101829
101830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101831   void * jresult ;
101832   Dali::Devel::PixelBuffer *arg1 = 0 ;
101833   Dali::Devel::PixelBuffer *result = 0 ;
101834
101835   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101836   if (!arg1) {
101837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101838     return 0;
101839   }
101840   {
101841     try {
101842       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101843     } catch (std::out_of_range& e) {
101844       {
101845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101846       };
101847     } catch (std::exception& e) {
101848       {
101849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101850       };
101851     } catch (...) {
101852       {
101853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101854       };
101855     }
101856   }
101857   jresult = (void *)result;
101858   return jresult;
101859 }
101860
101861
101862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101863   void * jresult ;
101864   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101865   Dali::Devel::PixelBuffer *arg2 = 0 ;
101866   Dali::Devel::PixelBuffer *result = 0 ;
101867
101868   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101869   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101870   if (!arg2) {
101871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101872     return 0;
101873   }
101874   {
101875     try {
101876       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101877     } catch (std::out_of_range& e) {
101878       {
101879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101880       };
101881     } catch (std::exception& e) {
101882       {
101883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101884       };
101885     } catch (...) {
101886       {
101887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101888       };
101889     }
101890   }
101891   jresult = (void *)result;
101892   return jresult;
101893 }
101894
101895
101896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101897   void * jresult ;
101898   Dali::Devel::PixelBuffer *arg1 = 0 ;
101899   Dali::PixelData result;
101900
101901   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101902   if (!arg1) {
101903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101904     return 0;
101905   }
101906   {
101907     try {
101908       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101909     } catch (std::out_of_range& e) {
101910       {
101911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101912       };
101913     } catch (std::exception& e) {
101914       {
101915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101916       };
101917     } catch (...) {
101918       {
101919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101920       };
101921     }
101922   }
101923   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101924   return jresult;
101925 }
101926
101927
101928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101929   void * jresult ;
101930   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101931   Dali::PixelData result;
101932
101933   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101934   {
101935     try {
101936       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101937     } catch (std::out_of_range& e) {
101938       {
101939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101940       };
101941     } catch (std::exception& e) {
101942       {
101943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101944       };
101945     } catch (...) {
101946       {
101947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101948       };
101949     }
101950   }
101951   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101952   return jresult;
101953 }
101954
101955
101956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101957   void * jresult ;
101958   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101959   unsigned char *result = 0 ;
101960
101961   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101962   {
101963     try {
101964       result = (unsigned char *)(arg1)->GetBuffer();
101965     } catch (std::out_of_range& e) {
101966       {
101967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101968       };
101969     } catch (std::exception& e) {
101970       {
101971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101972       };
101973     } catch (...) {
101974       {
101975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101976       };
101977     }
101978   }
101979   jresult = (void *)result;
101980   return jresult;
101981 }
101982
101983
101984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101985   unsigned int jresult ;
101986   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101987   unsigned int result;
101988
101989   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101990   {
101991     try {
101992       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101993     } catch (std::out_of_range& e) {
101994       {
101995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101996       };
101997     } catch (std::exception& e) {
101998       {
101999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102000       };
102001     } catch (...) {
102002       {
102003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102004       };
102005     }
102006   }
102007   jresult = result;
102008   return jresult;
102009 }
102010
102011
102012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102013   unsigned int jresult ;
102014   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102015   unsigned int result;
102016
102017   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102018   {
102019     try {
102020       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102021     } catch (std::out_of_range& e) {
102022       {
102023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102024       };
102025     } catch (std::exception& e) {
102026       {
102027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102028       };
102029     } catch (...) {
102030       {
102031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102032       };
102033     }
102034   }
102035   jresult = result;
102036   return jresult;
102037 }
102038
102039
102040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102041   int jresult ;
102042   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102043   Dali::Pixel::Format result;
102044
102045   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102046   {
102047     try {
102048       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102049     } catch (std::out_of_range& e) {
102050       {
102051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102052       };
102053     } catch (std::exception& e) {
102054       {
102055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102056       };
102057     } catch (...) {
102058       {
102059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102060       };
102061     }
102062   }
102063   jresult = (int)result;
102064   return jresult;
102065 }
102066
102067
102068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102069   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102070   Dali::Devel::PixelBuffer arg2 ;
102071   float arg3 ;
102072   bool arg4 ;
102073   Dali::Devel::PixelBuffer *argp2 ;
102074
102075   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102076   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102077   if (!argp2) {
102078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102079     return ;
102080   }
102081   arg2 = *argp2;
102082   arg3 = (float)jarg3;
102083   arg4 = jarg4 ? true : false;
102084   {
102085     try {
102086       (arg1)->ApplyMask(arg2,arg3,arg4);
102087     } catch (std::out_of_range& e) {
102088       {
102089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102090       };
102091     } catch (std::exception& e) {
102092       {
102093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102094       };
102095     } catch (...) {
102096       {
102097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102098       };
102099     }
102100   }
102101 }
102102
102103
102104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102105   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102106   Dali::Devel::PixelBuffer arg2 ;
102107   float arg3 ;
102108   Dali::Devel::PixelBuffer *argp2 ;
102109
102110   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102111   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102112   if (!argp2) {
102113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102114     return ;
102115   }
102116   arg2 = *argp2;
102117   arg3 = (float)jarg3;
102118   {
102119     try {
102120       (arg1)->ApplyMask(arg2,arg3);
102121     } catch (std::out_of_range& e) {
102122       {
102123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102124       };
102125     } catch (std::exception& e) {
102126       {
102127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102128       };
102129     } catch (...) {
102130       {
102131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102132       };
102133     }
102134   }
102135 }
102136
102137
102138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102139   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102140   Dali::Devel::PixelBuffer arg2 ;
102141   Dali::Devel::PixelBuffer *argp2 ;
102142
102143   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102144   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102145   if (!argp2) {
102146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102147     return ;
102148   }
102149   arg2 = *argp2;
102150   {
102151     try {
102152       (arg1)->ApplyMask(arg2);
102153     } catch (std::out_of_range& e) {
102154       {
102155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102156       };
102157     } catch (std::exception& e) {
102158       {
102159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102160       };
102161     } catch (...) {
102162       {
102163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102164       };
102165     }
102166   }
102167 }
102168
102169
102170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102171   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102172   float arg2 ;
102173
102174   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102175   arg2 = (float)jarg2;
102176   {
102177     try {
102178       (arg1)->ApplyGaussianBlur(arg2);
102179     } catch (std::out_of_range& e) {
102180       {
102181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102182       };
102183     } catch (std::exception& e) {
102184       {
102185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102186       };
102187     } catch (...) {
102188       {
102189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102190       };
102191     }
102192   }
102193 }
102194
102195
102196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102197   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102198   uint16_t arg2 ;
102199   uint16_t arg3 ;
102200   uint16_t arg4 ;
102201   uint16_t arg5 ;
102202
102203   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102204   arg2 = (uint16_t)jarg2;
102205   arg3 = (uint16_t)jarg3;
102206   arg4 = (uint16_t)jarg4;
102207   arg5 = (uint16_t)jarg5;
102208   {
102209     try {
102210       (arg1)->Crop(arg2,arg3,arg4,arg5);
102211     } catch (std::out_of_range& e) {
102212       {
102213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102214       };
102215     } catch (std::exception& e) {
102216       {
102217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102218       };
102219     } catch (...) {
102220       {
102221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102222       };
102223     }
102224   }
102225 }
102226
102227
102228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102229   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102230   uint16_t arg2 ;
102231   uint16_t arg3 ;
102232
102233   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102234   arg2 = (uint16_t)jarg2;
102235   arg3 = (uint16_t)jarg3;
102236   {
102237     try {
102238       (arg1)->Resize(arg2,arg3);
102239     } catch (std::out_of_range& e) {
102240       {
102241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102242       };
102243     } catch (std::exception& e) {
102244       {
102245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102246       };
102247     } catch (...) {
102248       {
102249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102250       };
102251     }
102252   }
102253 }
102254
102255
102256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102257   void * jresult ;
102258   std::string *arg1 = 0 ;
102259   Dali::ImageDimensions arg2 ;
102260   Dali::FittingMode::Type arg3 ;
102261   Dali::SamplingMode::Type arg4 ;
102262   bool arg5 ;
102263   Dali::ImageDimensions *argp2 ;
102264   Dali::Devel::PixelBuffer result;
102265
102266   if (!jarg1) {
102267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102268     return 0;
102269   }
102270   std::string arg1_str(jarg1);
102271   arg1 = &arg1_str;
102272   argp2 = (Dali::ImageDimensions *)jarg2;
102273   if (!argp2) {
102274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102275     return 0;
102276   }
102277   arg2 = *argp2;
102278   arg3 = (Dali::FittingMode::Type)jarg3;
102279   arg4 = (Dali::SamplingMode::Type)jarg4;
102280   arg5 = jarg5 ? true : false;
102281   {
102282     try {
102283       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102284     } catch (std::out_of_range& e) {
102285       {
102286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102287       };
102288     } catch (std::exception& e) {
102289       {
102290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102291       };
102292     } catch (...) {
102293       {
102294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102295       };
102296     }
102297   }
102298   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102299
102300   return jresult;
102301 }
102302
102303
102304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102305   void * jresult ;
102306   std::string *arg1 = 0 ;
102307   Dali::ImageDimensions arg2 ;
102308   Dali::FittingMode::Type arg3 ;
102309   Dali::SamplingMode::Type arg4 ;
102310   Dali::ImageDimensions *argp2 ;
102311   Dali::Devel::PixelBuffer result;
102312
102313   if (!jarg1) {
102314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102315     return 0;
102316   }
102317   std::string arg1_str(jarg1);
102318   arg1 = &arg1_str;
102319   argp2 = (Dali::ImageDimensions *)jarg2;
102320   if (!argp2) {
102321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102322     return 0;
102323   }
102324   arg2 = *argp2;
102325   arg3 = (Dali::FittingMode::Type)jarg3;
102326   arg4 = (Dali::SamplingMode::Type)jarg4;
102327   {
102328     try {
102329       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102330     } catch (std::out_of_range& e) {
102331       {
102332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102333       };
102334     } catch (std::exception& e) {
102335       {
102336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102337       };
102338     } catch (...) {
102339       {
102340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102341       };
102342     }
102343   }
102344   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102345
102346   return jresult;
102347 }
102348
102349
102350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102351   void * jresult ;
102352   std::string *arg1 = 0 ;
102353   Dali::ImageDimensions arg2 ;
102354   Dali::FittingMode::Type arg3 ;
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   arg3 = (Dali::FittingMode::Type)jarg3;
102371   {
102372     try {
102373       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102374     } catch (std::out_of_range& e) {
102375       {
102376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102377       };
102378     } catch (std::exception& e) {
102379       {
102380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102381       };
102382     } catch (...) {
102383       {
102384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102385       };
102386     }
102387   }
102388   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102389
102390   return jresult;
102391 }
102392
102393
102394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102395   void * jresult ;
102396   std::string *arg1 = 0 ;
102397   Dali::ImageDimensions arg2 ;
102398   Dali::ImageDimensions *argp2 ;
102399   Dali::Devel::PixelBuffer result;
102400
102401   if (!jarg1) {
102402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102403     return 0;
102404   }
102405   std::string arg1_str(jarg1);
102406   arg1 = &arg1_str;
102407   argp2 = (Dali::ImageDimensions *)jarg2;
102408   if (!argp2) {
102409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102410     return 0;
102411   }
102412   arg2 = *argp2;
102413   {
102414     try {
102415       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102416     } catch (std::out_of_range& e) {
102417       {
102418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102419       };
102420     } catch (std::exception& e) {
102421       {
102422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102423       };
102424     } catch (...) {
102425       {
102426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102427       };
102428     }
102429   }
102430   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102431
102432   return jresult;
102433 }
102434
102435
102436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102437   void * jresult ;
102438   std::string *arg1 = 0 ;
102439   Dali::Devel::PixelBuffer result;
102440
102441   if (!jarg1) {
102442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102443     return 0;
102444   }
102445   std::string arg1_str(jarg1);
102446   arg1 = &arg1_str;
102447   {
102448     try {
102449       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102450     } catch (std::out_of_range& e) {
102451       {
102452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102453       };
102454     } catch (std::exception& e) {
102455       {
102456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102457       };
102458     } catch (...) {
102459       {
102460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102461       };
102462     }
102463   }
102464   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102465
102466   return jresult;
102467 }
102468
102469
102470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102471   void * jresult ;
102472   std::string *arg1 = 0 ;
102473   Dali::ImageDimensions arg2 ;
102474   Dali::FittingMode::Type arg3 ;
102475   Dali::SamplingMode::Type arg4 ;
102476   bool arg5 ;
102477   Dali::ImageDimensions *argp2 ;
102478   Dali::ImageDimensions result;
102479
102480   if (!jarg1) {
102481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102482     return 0;
102483   }
102484   std::string arg1_str(jarg1);
102485   arg1 = &arg1_str;
102486   argp2 = (Dali::ImageDimensions *)jarg2;
102487   if (!argp2) {
102488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102489     return 0;
102490   }
102491   arg2 = *argp2;
102492   arg3 = (Dali::FittingMode::Type)jarg3;
102493   arg4 = (Dali::SamplingMode::Type)jarg4;
102494   arg5 = jarg5 ? true : false;
102495   {
102496     try {
102497       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102498     } catch (std::out_of_range& e) {
102499       {
102500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102501       };
102502     } catch (std::exception& e) {
102503       {
102504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102505       };
102506     } catch (...) {
102507       {
102508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102509       };
102510     }
102511   }
102512   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102513
102514   return jresult;
102515 }
102516
102517
102518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102519   void * jresult ;
102520   std::string *arg1 = 0 ;
102521   Dali::ImageDimensions arg2 ;
102522   Dali::FittingMode::Type arg3 ;
102523   Dali::SamplingMode::Type arg4 ;
102524   Dali::ImageDimensions *argp2 ;
102525   Dali::ImageDimensions result;
102526
102527   if (!jarg1) {
102528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102529     return 0;
102530   }
102531   std::string arg1_str(jarg1);
102532   arg1 = &arg1_str;
102533   argp2 = (Dali::ImageDimensions *)jarg2;
102534   if (!argp2) {
102535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102536     return 0;
102537   }
102538   arg2 = *argp2;
102539   arg3 = (Dali::FittingMode::Type)jarg3;
102540   arg4 = (Dali::SamplingMode::Type)jarg4;
102541   {
102542     try {
102543       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102544     } catch (std::out_of_range& e) {
102545       {
102546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102547       };
102548     } catch (std::exception& e) {
102549       {
102550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102551       };
102552     } catch (...) {
102553       {
102554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102555       };
102556     }
102557   }
102558   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102559
102560   return jresult;
102561 }
102562
102563
102564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102565   void * jresult ;
102566   std::string *arg1 = 0 ;
102567   Dali::ImageDimensions arg2 ;
102568   Dali::FittingMode::Type arg3 ;
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   arg3 = (Dali::FittingMode::Type)jarg3;
102585   {
102586     try {
102587       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102588     } catch (std::out_of_range& e) {
102589       {
102590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102591       };
102592     } catch (std::exception& e) {
102593       {
102594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102595       };
102596     } catch (...) {
102597       {
102598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102599       };
102600     }
102601   }
102602   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102603
102604   return jresult;
102605 }
102606
102607
102608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102609   void * jresult ;
102610   std::string *arg1 = 0 ;
102611   Dali::ImageDimensions arg2 ;
102612   Dali::ImageDimensions *argp2 ;
102613   Dali::ImageDimensions result;
102614
102615   if (!jarg1) {
102616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102617     return 0;
102618   }
102619   std::string arg1_str(jarg1);
102620   arg1 = &arg1_str;
102621   argp2 = (Dali::ImageDimensions *)jarg2;
102622   if (!argp2) {
102623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102624     return 0;
102625   }
102626   arg2 = *argp2;
102627   {
102628     try {
102629       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102630     } catch (std::out_of_range& e) {
102631       {
102632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102633       };
102634     } catch (std::exception& e) {
102635       {
102636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102637       };
102638     } catch (...) {
102639       {
102640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102641       };
102642     }
102643   }
102644   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102645
102646   return jresult;
102647 }
102648
102649
102650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102651   void * jresult ;
102652   std::string *arg1 = 0 ;
102653   Dali::ImageDimensions result;
102654
102655   if (!jarg1) {
102656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102657     return 0;
102658   }
102659   std::string arg1_str(jarg1);
102660   arg1 = &arg1_str;
102661   {
102662     try {
102663       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102664     } catch (std::out_of_range& e) {
102665       {
102666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102667       };
102668     } catch (std::exception& e) {
102669       {
102670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102671       };
102672     } catch (...) {
102673       {
102674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102675       };
102676     }
102677   }
102678   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102679
102680   return jresult;
102681 }
102682
102683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102684   void * jresult ;
102685   std::string *arg1 = 0 ;
102686   Dali::ImageDimensions result;
102687
102688   if (!jarg1) {
102689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102690     return 0;
102691   }
102692   std::string arg1_str(jarg1);
102693   arg1 = &arg1_str;
102694   {
102695     try {
102696       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
102697     } catch (std::out_of_range& e) {
102698       {
102699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102700       };
102701     } catch (std::exception& e) {
102702       {
102703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102704       };
102705     } catch (...) {
102706       {
102707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102708       };
102709     }
102710   }
102711   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102712
102713   return jresult;
102714 }
102715
102716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102717   void * jresult ;
102718   std::string *arg1 = 0 ;
102719   Dali::ImageDimensions arg2 ;
102720   Dali::FittingMode::Type arg3 ;
102721   Dali::SamplingMode::Type arg4 ;
102722   bool arg5 ;
102723   Dali::ImageDimensions *argp2 ;
102724   Dali::Devel::PixelBuffer result;
102725
102726   if (!jarg1) {
102727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102728     return 0;
102729   }
102730   std::string arg1_str(jarg1);
102731   arg1 = &arg1_str;
102732   argp2 = (Dali::ImageDimensions *)jarg2;
102733   if (!argp2) {
102734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102735     return 0;
102736   }
102737   arg2 = *argp2;
102738   arg3 = (Dali::FittingMode::Type)jarg3;
102739   arg4 = (Dali::SamplingMode::Type)jarg4;
102740   arg5 = jarg5 ? true : false;
102741   {
102742     try {
102743       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102744     } catch (std::out_of_range& e) {
102745       {
102746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102747       };
102748     } catch (std::exception& e) {
102749       {
102750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102751       };
102752     } catch (...) {
102753       {
102754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102755       };
102756     }
102757   }
102758   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102759
102760   return jresult;
102761 }
102762
102763
102764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102765   void * jresult ;
102766   std::string *arg1 = 0 ;
102767   Dali::ImageDimensions arg2 ;
102768   Dali::FittingMode::Type arg3 ;
102769   Dali::SamplingMode::Type arg4 ;
102770   Dali::ImageDimensions *argp2 ;
102771   Dali::Devel::PixelBuffer result;
102772
102773   if (!jarg1) {
102774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102775     return 0;
102776   }
102777   std::string arg1_str(jarg1);
102778   arg1 = &arg1_str;
102779   argp2 = (Dali::ImageDimensions *)jarg2;
102780   if (!argp2) {
102781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102782     return 0;
102783   }
102784   arg2 = *argp2;
102785   arg3 = (Dali::FittingMode::Type)jarg3;
102786   arg4 = (Dali::SamplingMode::Type)jarg4;
102787   {
102788     try {
102789       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102790     } catch (std::out_of_range& e) {
102791       {
102792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102793       };
102794     } catch (std::exception& e) {
102795       {
102796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102797       };
102798     } catch (...) {
102799       {
102800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102801       };
102802     }
102803   }
102804   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102805
102806   return jresult;
102807 }
102808
102809
102810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102811   void * jresult ;
102812   std::string *arg1 = 0 ;
102813   Dali::ImageDimensions arg2 ;
102814   Dali::FittingMode::Type arg3 ;
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   arg3 = (Dali::FittingMode::Type)jarg3;
102831   {
102832     try {
102833       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102834     } catch (std::out_of_range& e) {
102835       {
102836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102837       };
102838     } catch (std::exception& e) {
102839       {
102840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102841       };
102842     } catch (...) {
102843       {
102844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102845       };
102846     }
102847   }
102848   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102849
102850   return jresult;
102851 }
102852
102853
102854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102855   void * jresult ;
102856   std::string *arg1 = 0 ;
102857   Dali::ImageDimensions arg2 ;
102858   Dali::ImageDimensions *argp2 ;
102859   Dali::Devel::PixelBuffer result;
102860
102861   if (!jarg1) {
102862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102863     return 0;
102864   }
102865   std::string arg1_str(jarg1);
102866   arg1 = &arg1_str;
102867   argp2 = (Dali::ImageDimensions *)jarg2;
102868   if (!argp2) {
102869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102870     return 0;
102871   }
102872   arg2 = *argp2;
102873   {
102874     try {
102875       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102876     } catch (std::out_of_range& e) {
102877       {
102878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102879       };
102880     } catch (std::exception& e) {
102881       {
102882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102883       };
102884     } catch (...) {
102885       {
102886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102887       };
102888     }
102889   }
102890   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102891
102892   return jresult;
102893 }
102894
102895
102896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102897   void * jresult ;
102898   std::string *arg1 = 0 ;
102899   Dali::Devel::PixelBuffer result;
102900
102901   if (!jarg1) {
102902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102903     return 0;
102904   }
102905   std::string arg1_str(jarg1);
102906   arg1 = &arg1_str;
102907   {
102908     try {
102909       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102910     } catch (std::out_of_range& e) {
102911       {
102912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102913       };
102914     } catch (std::exception& e) {
102915       {
102916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102917       };
102918     } catch (...) {
102919       {
102920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102921       };
102922     }
102923   }
102924   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102925
102926   return jresult;
102927 }
102928
102929
102930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102931   void * jresult ;
102932   Dali::Toolkit::WebView result;
102933
102934   {
102935     try {
102936       result = Dali::Toolkit::WebView::New();
102937     } catch (std::out_of_range& e) {
102938       {
102939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102940       };
102941     } catch (std::exception& e) {
102942       {
102943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102944       };
102945     } catch (Dali::DaliException e) {
102946       {
102947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102948       };
102949     } catch (...) {
102950       {
102951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102952       };
102953     }
102954   }
102955   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102956   return jresult;
102957 }
102958
102959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102960   void * jresult ;
102961   Dali::Toolkit::WebView result;
102962
102963   std::string *arg1;
102964   std::string *arg2;
102965
102966   if (!jarg1) {
102967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102968     return 0;
102969   }
102970   if (!jarg2) {
102971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102972     return 0;
102973   }
102974
102975   std::string jarg1_str = std::string(jarg1);
102976   std::string jarg2_str = std::string(jarg2);
102977
102978   arg1 = &jarg1_str;
102979   arg2 = &jarg2_str;
102980
102981   {
102982     try {
102983       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102984     } catch (std::out_of_range& e) {
102985       {
102986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102987       };
102988     } catch (std::exception& e) {
102989       {
102990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102991       };
102992     } catch (Dali::DaliException e) {
102993       {
102994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102995       };
102996     } catch (...) {
102997       {
102998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102999       };
103000     }
103001   }
103002   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103003   return jresult;
103004 }
103005
103006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103007   void * jresult ;
103008   Dali::Toolkit::WebView *arg1 = 0 ;
103009   Dali::Toolkit::WebView *result = 0 ;
103010
103011   arg1 = (Dali::Toolkit::WebView *)jarg1;
103012   if (!arg1) {
103013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103014     return 0;
103015   }
103016   {
103017     try {
103018       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103019     } catch (std::out_of_range& e) {
103020       {
103021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103022       };
103023     } catch (std::exception& e) {
103024       {
103025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103026       };
103027     } catch (Dali::DaliException e) {
103028       {
103029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103030       };
103031     } catch (...) {
103032       {
103033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103034       };
103035     }
103036   }
103037   jresult = (void *)result;
103038   return jresult;
103039 }
103040
103041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103042   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103043   arg1 = (Dali::Toolkit::WebView *)jarg1;
103044   {
103045     try {
103046       delete arg1;
103047     } catch (std::out_of_range& e) {
103048       {
103049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103050       };
103051     } catch (std::exception& e) {
103052       {
103053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103054       };
103055     } catch (Dali::DaliException e) {
103056       {
103057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103058       };
103059     } catch (...) {
103060       {
103061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103062       };
103063     }
103064   }
103065 }
103066
103067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103068   void * jresult ;
103069   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103070   Dali::Toolkit::WebView *arg2 = 0 ;
103071   Dali::Toolkit::WebView *result = 0 ;
103072
103073   arg1 = (Dali::Toolkit::WebView *)jarg1;
103074   arg2 = (Dali::Toolkit::WebView *)jarg2;
103075   if (!arg2) {
103076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103077     return 0;
103078   }
103079   {
103080     try {
103081       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103082     } catch (std::out_of_range& e) {
103083       {
103084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103085       };
103086     } catch (std::exception& e) {
103087       {
103088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103089       };
103090     } catch (Dali::DaliException e) {
103091       {
103092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103093       };
103094     } catch (...) {
103095       {
103096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103097       };
103098     }
103099   }
103100   jresult = (void *)result;
103101   return jresult;
103102 }
103103
103104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103105   void * jresult ;
103106   Dali::BaseHandle arg1 ;
103107   Dali::BaseHandle *argp1 ;
103108   Dali::Toolkit::WebView result;
103109
103110   argp1 = (Dali::BaseHandle *)jarg1;
103111   if (!argp1) {
103112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103113     return 0;
103114   }
103115   arg1 = *argp1;
103116   {
103117     try {
103118       result = Dali::Toolkit::WebView::DownCast(arg1);
103119     } catch (std::out_of_range& e) {
103120       {
103121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103122       };
103123     } catch (std::exception& e) {
103124       {
103125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103126       };
103127     } catch (Dali::DaliException e) {
103128       {
103129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103130       };
103131     } catch (...) {
103132       {
103133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103134       };
103135     }
103136   }
103137   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103138   return jresult;
103139 }
103140
103141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
103142   return (int) Dali::Toolkit::WebView::Property::URL;
103143 }
103144
103145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
103146   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
103147 }
103148
103149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
103150   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
103151 }
103152
103153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
103154   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
103155 }
103156
103157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
103158   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
103159 }
103160
103161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
103162   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
103163 }
103164
103165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
103166   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
103167 }
103168
103169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
103170   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
103171 }
103172
103173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103174   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103175   std::string *arg2;
103176
103177   arg1 = (Dali::Toolkit::WebView *)jarg1;
103178
103179   if (!jarg2) {
103180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103181     return;
103182   }
103183
103184   std::string jarg2str = std::string(jarg2);
103185   arg2 = &jarg2str;
103186   {
103187     try {
103188       (arg1)->LoadUrl((std::string const &)*arg2);
103189     } catch (std::out_of_range& e) {
103190       {
103191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103192       };
103193     } catch (std::exception& e) {
103194       {
103195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103196       };
103197     } catch (Dali::DaliException e) {
103198       {
103199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103200       };
103201     } catch (...) {
103202       {
103203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103204       };
103205     }
103206   }
103207 }
103208
103209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103210   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103211   std::string *arg2;
103212
103213   arg1 = (Dali::Toolkit::WebView *)jarg1;
103214   if (!jarg2) {
103215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103216     return;
103217   }
103218   std::string jarg2str = std::string(jarg2);
103219   arg2 = &jarg2str;
103220   {
103221     try {
103222       (arg1)->LoadHTMLString((std::string const &)*arg2);
103223     } catch (std::out_of_range& e) {
103224       {
103225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103226       };
103227     } catch (std::exception& e) {
103228       {
103229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103230       };
103231     } catch (Dali::DaliException e) {
103232       {
103233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103234       };
103235     } catch (...) {
103236       {
103237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103238       };
103239     }
103240   }
103241 }
103242
103243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103244   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103245
103246   arg1 = (Dali::Toolkit::WebView *)jarg1;
103247   {
103248     try {
103249       (arg1)->Reload();
103250     } catch (std::out_of_range& e) {
103251       {
103252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103253       };
103254     } catch (std::exception& e) {
103255       {
103256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103257       };
103258     } catch (Dali::DaliException e) {
103259       {
103260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103261       };
103262     } catch (...) {
103263       {
103264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103265       };
103266     }
103267   }
103268 }
103269
103270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103271   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103272
103273   arg1 = (Dali::Toolkit::WebView *)jarg1;
103274   {
103275     try {
103276       (arg1)->StopLoading();
103277     } catch (std::out_of_range& e) {
103278       {
103279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103280       };
103281     } catch (std::exception& e) {
103282       {
103283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103284       };
103285     } catch (Dali::DaliException e) {
103286       {
103287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103288       };
103289     } catch (...) {
103290       {
103291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103292       };
103293     }
103294   }
103295 }
103296
103297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
103298   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103299
103300   arg1 = (Dali::Toolkit::WebView *)jarg1;
103301   {
103302     try {
103303       (arg1)->Suspend();
103304     } catch (std::out_of_range& e) {
103305       {
103306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103307       };
103308     } catch (std::exception& e) {
103309       {
103310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103311       };
103312     } catch (Dali::DaliException e) {
103313       {
103314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103315       };
103316     } catch (...) {
103317       {
103318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103319       };
103320     }
103321   }
103322 }
103323
103324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
103325   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103326
103327   arg1 = (Dali::Toolkit::WebView *)jarg1;
103328   {
103329     try {
103330       (arg1)->Resume();
103331     } catch (std::out_of_range& e) {
103332       {
103333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103334       };
103335     } catch (std::exception& e) {
103336       {
103337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103338       };
103339     } catch (Dali::DaliException e) {
103340       {
103341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103342       };
103343     } catch (...) {
103344       {
103345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103346       };
103347     }
103348   }
103349 }
103350
103351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103352   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103353
103354   arg1 = (Dali::Toolkit::WebView *)jarg1;
103355   {
103356     try {
103357       (arg1)->GoBack();
103358     } catch (std::out_of_range& e) {
103359       {
103360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103361       };
103362     } catch (std::exception& e) {
103363       {
103364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103365       };
103366     } catch (Dali::DaliException e) {
103367       {
103368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103369       };
103370     } catch (...) {
103371       {
103372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103373       };
103374     }
103375   }
103376 }
103377
103378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103379   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103380
103381   arg1 = (Dali::Toolkit::WebView *)jarg1;
103382   {
103383     try {
103384       (arg1)->GoForward();
103385     } catch (std::out_of_range& e) {
103386       {
103387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103388       };
103389     } catch (std::exception& e) {
103390       {
103391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103392       };
103393     } catch (Dali::DaliException e) {
103394       {
103395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103396       };
103397     } catch (...) {
103398       {
103399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103400       };
103401     }
103402   }
103403 }
103404
103405 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103406   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103407   bool ret;
103408
103409   arg1 = (Dali::Toolkit::WebView *)jarg1;
103410   {
103411     try {
103412       ret = (arg1)->CanGoBack();
103413     } catch (std::out_of_range& e) {
103414       {
103415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103416       };
103417     } catch (std::exception& e) {
103418       {
103419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103420       };
103421     } catch (Dali::DaliException e) {
103422       {
103423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103424       };
103425     } catch (...) {
103426       {
103427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103428       };
103429     }
103430   }
103431   return ret;
103432 }
103433
103434 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103435   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103436   bool ret;
103437
103438   arg1 = (Dali::Toolkit::WebView *)jarg1;
103439   {
103440     try {
103441       ret = (arg1)->CanGoForward();
103442     } catch (std::out_of_range& e) {
103443       {
103444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103445       };
103446     } catch (std::exception& e) {
103447       {
103448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103449       };
103450     } catch (Dali::DaliException e) {
103451       {
103452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103453       };
103454     } catch (...) {
103455       {
103456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103457       };
103458     }
103459   }
103460   return ret;
103461 }
103462
103463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
103464   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103465   std::string *arg2;
103466
103467   arg1 = (Dali::Toolkit::WebView *)jarg1;
103468   if (!jarg2) {
103469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103470     return;
103471   }
103472   std::string jarg2_str = std::string(jarg2);
103473   arg2 = &jarg2_str;
103474
103475   {
103476     try {
103477       if (jarg3) {
103478         void (*handler)(char*) = (void (*)(char*)) jarg3;
103479         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
103480           handler(SWIG_csharp_string_callback(result.c_str()));
103481         });
103482       } else {
103483         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
103484       }
103485     } catch (std::out_of_range& e) {
103486       {
103487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103488       };
103489     } catch (std::exception& e) {
103490       {
103491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103492       };
103493     } catch (Dali::DaliException e) {
103494       {
103495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103496       };
103497     } catch (...) {
103498       {
103499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103500       };
103501     }
103502   }
103503 }
103504
103505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103506 {
103507   if (!jarg2) {
103508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103509     return;
103510   }
103511
103512   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103513   std::string exposedObjectName = jarg2;
103514   void (*handler)(char*) = (void (*)(char*)) jarg3;
103515
103516   {
103517     try {
103518       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103519         handler(SWIG_csharp_string_callback(message.c_str()));
103520       });
103521     } catch (std::out_of_range& e) {
103522       {
103523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103524       };
103525     } catch (std::exception& e) {
103526       {
103527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103528       };
103529     } catch (Dali::DaliException e) {
103530       {
103531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103532       };
103533     } catch (...) {
103534       {
103535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103536       };
103537     }
103538   }
103539 }
103540
103541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103542   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103543
103544   arg1 = (Dali::Toolkit::WebView *)jarg1;
103545   {
103546     try {
103547       (arg1)->ClearHistory();
103548     } catch (std::out_of_range& e) {
103549       {
103550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103551       };
103552     } catch (std::exception& e) {
103553       {
103554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103555       };
103556     } catch (Dali::DaliException e) {
103557       {
103558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103559       };
103560     } catch (...) {
103561       {
103562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103563       };
103564     }
103565   }
103566 }
103567
103568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103569   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103570
103571   arg1 = (Dali::Toolkit::WebView *)jarg1;
103572   {
103573     try {
103574       (arg1)->ClearCache();
103575     } catch (std::out_of_range& e) {
103576       {
103577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103578       };
103579     } catch (std::exception& e) {
103580       {
103581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103582       };
103583     } catch (Dali::DaliException e) {
103584       {
103585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103586       };
103587     } catch (...) {
103588       {
103589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103590       };
103591     }
103592   }
103593 }
103594
103595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
103596   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103597
103598   arg1 = (Dali::Toolkit::WebView *)jarg1;
103599   {
103600     try {
103601       (arg1)->ClearCookies();
103602     } catch (std::out_of_range& e) {
103603       {
103604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103605       };
103606     } catch (std::exception& e) {
103607       {
103608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103609       };
103610     } catch (Dali::DaliException e) {
103611       {
103612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103613       };
103614     } catch (...) {
103615       {
103616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103617       };
103618     }
103619   }
103620 }
103621
103622 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103623     return (Dali::Toolkit::Control *)jarg1;
103624 }
103625
103626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
103627   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103628   SignalConverter::WebViewPageLoadSignal* result = NULL;
103629   {
103630     try {
103631       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
103632     } catch (std::out_of_range& e) {
103633       {
103634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103635       };
103636     } catch (std::exception& e) {
103637       {
103638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103639       };
103640     } catch (Dali::DaliException e) {
103641       {
103642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103643       };
103644     } catch (...) {
103645       {
103646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103647       };
103648     }
103649   }
103650   return (void*) result;
103651 }
103652
103653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
103654   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103655   SignalConverter::WebViewPageLoadSignal* result = NULL;
103656   {
103657     try {
103658       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
103659     } catch (std::out_of_range& e) {
103660       {
103661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103662       };
103663     } catch (std::exception& e) {
103664       {
103665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103666       };
103667     } catch (Dali::DaliException e) {
103668       {
103669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103670       };
103671     } catch (...) {
103672       {
103673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103674       };
103675     }
103676   }
103677   return (void*) result;
103678 }
103679
103680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
103681 {
103682   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103683   {
103684     try {
103685       delete object;
103686     } catch (std::out_of_range& e) {
103687       {
103688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103689       };
103690     } catch (std::exception& e) {
103691       {
103692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103693       };
103694     } catch (Dali::DaliException e) {
103695       {
103696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103697       };
103698     } catch (...) {
103699       {
103700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103701       };
103702     }
103703   }
103704 }
103705
103706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
103707 {
103708   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103709   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103710   {
103711     try {
103712       proxy->Connect(callback);
103713     } catch (std::out_of_range& e) {
103714       {
103715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103716       };
103717     } catch (std::exception& e) {
103718       {
103719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103720       };
103721     } catch (Dali::DaliException e) {
103722       {
103723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103724       };
103725     } catch (...) {
103726       {
103727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103728       };
103729     }
103730   }
103731 }
103732
103733
103734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
103735   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103736   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103737   {
103738     try {
103739       proxy->Disconnect(callback);
103740     } catch (std::out_of_range& e) {
103741       {
103742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103743       };
103744     } catch (std::exception& e) {
103745       {
103746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103747       };
103748     } catch (Dali::DaliException e) {
103749       {
103750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103751       };
103752     } catch (...) {
103753       {
103754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103755       };
103756     }
103757   }
103758 }
103759
103760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
103761   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103762   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
103763   {
103764     try {
103765       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
103766     } catch (std::out_of_range& e) {
103767       {
103768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103769       };
103770     } catch (std::exception& e) {
103771       {
103772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103773       };
103774     } catch (Dali::DaliException e) {
103775       {
103776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103777       };
103778     } catch (...) {
103779       {
103780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103781       };
103782     }
103783   }
103784   return (void*) result;
103785 }
103786
103787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
103788 {
103789   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103790   {
103791     try {
103792       delete object;
103793     } catch (std::out_of_range& e) {
103794       {
103795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103796       };
103797     } catch (std::exception& e) {
103798       {
103799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103800       };
103801     } catch (Dali::DaliException e) {
103802       {
103803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103804       };
103805     } catch (...) {
103806       {
103807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103808       };
103809     }
103810   }
103811 }
103812
103813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
103814 {
103815   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103816   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103817   {
103818     try {
103819       proxy->Connect(callback);
103820     } catch (std::out_of_range& e) {
103821       {
103822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103823       };
103824     } catch (std::exception& e) {
103825       {
103826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103827       };
103828     } catch (Dali::DaliException e) {
103829       {
103830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103831       };
103832     } catch (...) {
103833       {
103834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103835       };
103836     }
103837   }
103838 }
103839
103840
103841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103842   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103843   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103844   {
103845     try {
103846       proxy->Disconnect(callback);
103847     } catch (std::out_of_range& e) {
103848       {
103849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103850       };
103851     } catch (std::exception& e) {
103852       {
103853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103854       };
103855     } catch (Dali::DaliException e) {
103856       {
103857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103858       };
103859     } catch (...) {
103860       {
103861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103862       };
103863     }
103864   }
103865 }
103866
103867 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103868   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103869   char * jresult = SWIG_csharp_string_callback((const char *)result);
103870   return jresult;
103871 }
103872
103873 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103874   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103875   return result;
103876 }
103877
103878 #ifdef __cplusplus
103879 }
103880 #endif
103881